import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
from statsmodels.tsa.seasonal import seasonal_decompose
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from statsmodels.tsa.holtwinters import ExponentialSmoothing
import wordcloud
from wordcloud import WordCloud
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_squared_error
from pmdarima import auto_arima
from datetime import datetime
from lifelines import KaplanMeierFitter
from lifelines import CoxPHFitter

warnings.filterwarnings("ignore")

data_swire = pd.read_csv('IWC_Work_Orders_Extract.csv', low_memory=False)

data_swire_copy = data_swire.copy()

data_swire_copy.head(n=10)

# Check column names and data types
data_swire_copy.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1427264 entries, 0 to 1427263
Data columns (total 25 columns):
 #   Column                           Non-Null Count    Dtype  
---  ------                           --------------    -----  
 0   ORDER_ID                         1427264 non-null  int64  
 1   PLANT_ID                         1427264 non-null  object 
 2   PRODUCTION_LOCATION              1427264 non-null  object 
 3   EXECUTION_START_DATE             1427264 non-null  object 
 4   EXECUTION_FINISH_DATE            1427264 non-null  object 
 5   ACTUAL_START_TIME                1427264 non-null  object 
 6   ACTUAL_FINISH_TIME               1427264 non-null  object 
 7   ACTUAL_WORK_IN_MINUTES           1427264 non-null  float64
 8   MAINTENANCE_PLAN                 152594 non-null   object 
 9   MAINTENANCE_ITEM                 152594 non-null   float64
 10  MAINTENANCE_ACTIVITY_TYPE        1427264 non-null  object 
 11  ORDER_DESCRIPTION                291767 non-null   object 
 12  MAINTENANCE_TYPE_DESCRIPTION     291795 non-null   object 
 13  FUNCTIONAL_LOC                   291782 non-null   object 
 14  FUNCTIONAL_AREA_NODE_1_MODIFIED  290117 non-null   object 
 15  FUNCTIONAL_AREA_NODE_2_MODIFIED  282407 non-null   object 
 16  FUNCTIONAL_AREA_NODE_3_MODIFIED  258691 non-null   object 
 17  FUNCTIONAL_AREA_NODE_4_MODIFIED  237573 non-null   object 
 18  FUNCTIONAL_AREA_NODE_5_MODIFIED  2180 non-null     object 
 19  EQUIPMENT_ID                     291795 non-null   float64
 20  EQUIPMENT_DESC                   79447 non-null    object 
 21  EQUIP_CAT_DESC                   79447 non-null    object 
 22  EQUIP_START_UP_DATE              79447 non-null    object 
 23  EQUIP_VALID_FROM                 79447 non-null    object 
 24  EQUIP_VALID_TO                   79447 non-null    object 
dtypes: float64(3), int64(1), object(21)
memory usage: 272.2+ MB

data_swire_copy.shape

(1427264, 25)

median_survival_times_dict = {}
for equipment_type in equipment_types:
    type_data = data_swire_copy[data_swire_copy['Equipment_Type'] == equipment_type.capitalize()]
    if not type_data.empty:
        kmf.fit(type_data['machine_age'], event_observed=type_data['failure_event'])
        median_survival = median_survival_times(kmf.survival_function_)
        median_survival_times_dict[equipment_type] = median_survival.values[0][0]

# Simulate the impact of planned maintenance
data_swire_copy['preventive_maintenance'] = data_swire_copy['machine_age'].apply(
    lambda x: 1 if any(x < median_survival_times_dict[etype] for etype in equipment_types if etype in str(data_swire_copy['EQUIPMENT_DESC'].iloc[0]).lower()) else 0
)

# Compare unplanned maintenance with and without the intervention
before_intervention = data_swire_copy['failure_event'].sum()
after_intervention = data_swire_copy.loc[data_swire_copy['preventive_maintenance'] == 0, 'failure_event'].sum()

print(f"Unplanned maintenance events before intervention: {before_intervention}")
print(f"Unplanned maintenance events after intervention: {after_intervention}")

# Calculate downtime reduction
downtime_reduction = (before_intervention - after_intervention) / before_intervention * 100
print(f"Estimated reduction in unplanned maintenance events: {downtime_reduction:.2f}%")

Unplanned maintenance events before intervention: 79447
Unplanned maintenance events after intervention: 79447
Estimated reduction in unplanned maintenance events: 0.00%

data_swire_copy.dtypes

data_swire_copy.columns

Index(['ORDER_ID', 'PLANT_ID', 'PRODUCTION_LOCATION', 'EXECUTION_START_DATE',
       'EXECUTION_FINISH_DATE', 'ACTUAL_START_TIME', 'ACTUAL_FINISH_TIME',
       'ACTUAL_WORK_IN_MINUTES', 'MAINTENANCE_PLAN', 'MAINTENANCE_ITEM',
       'MAINTENANCE_ACTIVITY_TYPE', 'ORDER_DESCRIPTION',
       'MAINTENANCE_TYPE_DESCRIPTION', 'FUNCTIONAL_LOC',
       'FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
       'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED',
       'FUNCTIONAL_AREA_NODE_5_MODIFIED', 'EQUIPMENT_ID', 'EQUIPMENT_DESC',
       'EQUIP_CAT_DESC', 'EQUIP_START_UP_DATE', 'EQUIP_VALID_FROM',
       'EQUIP_VALID_TO'],
      dtype='object')

data_swire_copy.isnull().sum()

# Calculate the percentage of missing values for each column
missing_values_percentage = data_swire_copy.isnull().mean() * 100

# Filter out columns that have no missing values
missing_values_percentage = missing_values_percentage[missing_values_percentage > 0]

print(missing_values_percentage)

MAINTENANCE_PLAN                   89.308635
MAINTENANCE_ITEM                   89.308635
ORDER_DESCRIPTION                  79.557601
MAINTENANCE_TYPE_DESCRIPTION       79.555639
FUNCTIONAL_LOC                     79.556550
FUNCTIONAL_AREA_NODE_1_MODIFIED    79.673207
FUNCTIONAL_AREA_NODE_2_MODIFIED    80.213401
FUNCTIONAL_AREA_NODE_3_MODIFIED    81.875042
FUNCTIONAL_AREA_NODE_4_MODIFIED    83.354656
FUNCTIONAL_AREA_NODE_5_MODIFIED    99.847260
EQUIPMENT_ID                       79.555639
EQUIPMENT_DESC                     94.433616
EQUIP_CAT_DESC                     94.433616
EQUIP_START_UP_DATE                94.433616
EQUIP_VALID_FROM                   94.433616
EQUIP_VALID_TO                     94.433616
dtype: float64

# Plotting the bar plot
plt.figure(figsize=(13, 8))
missing_values_percentage.sort_values().plot(kind='barh', color='skyblue')
plt.xlabel('Percentage of Missing Values')
plt.ylabel('Columns')
plt.title('Percentage of Missing Values by Column')

# Add numerical values on the bars
for index, value in enumerate(missing_values_percentage.sort_values()):
    plt.text(value + 0.5, index, f'{value:.2f}%', va='center')

plt.show()

categorical_columns = ['MAINTENANCE_PLAN', 'MAINTENANCE_ITEM', 'ORDER_DESCRIPTION', 'MAINTENANCE_TYPE_DESCRIPTION',
                       'FUNCTIONAL_LOC', 'FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
                       'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED', 'FUNCTIONAL_AREA_NODE_5_MODIFIED',
                       'EQUIPMENT_ID', 'EQUIPMENT_DESC', 'EQUIP_CAT_DESC']

for col in categorical_columns:
    data_swire_copy[col] = data_swire_copy[col].fillna('Unknown')

data_swire_copy['EQUIP_START_UP_DATE'] = pd.to_datetime(data_swire_copy['EQUIP_START_UP_DATE'], errors='coerce')
data_swire_copy['EQUIP_START_UP_DATE'] = data_swire_copy['EQUIP_START_UP_DATE'].fillna(pd.to_datetime('1960-01-01'))

data_swire_copy['EQUIP_VALID_FROM'] = np.where(
    data_swire_copy['EQUIP_VALID_FROM'].isna(),
    data_swire_copy['EQUIP_START_UP_DATE'] + pd.Timedelta(days=0),
    data_swire_copy['EQUIP_VALID_FROM']
)

data_swire_copy.fillna({'EQUIP_VALID_TO': pd.to_datetime('2200-01-01')}, inplace=True)


data_swire_copy['EQUIPMENT_DESC'] = data_swire_copy['EQUIPMENT_DESC'].fillna(data_swire_copy['EQUIPMENT_DESC'].mode()[0])
data_swire_copy['EQUIP_CAT_DESC'] = data_swire_copy['EQUIP_CAT_DESC'].fillna(data_swire_copy['EQUIP_CAT_DESC'].mode()[0])

data_swire_copy.isnull().sum()

data_swire_copy.head(n=10)

data_swire_copy['ACTUAL_WORK_IN_MINUTES'].describe().round(2)

warnings.filterwarnings("ignore", category=FutureWarning, module="pandas")

sns.histplot(data_swire_copy['ACTUAL_WORK_IN_MINUTES'], bins=30, kde=True)
plt.title('Distribution of Actual Work in Minutes')
plt.xlabel('Actual Work in Minutes')
plt.ylabel('Frequency')
plt.show()

plt.figure(figsize=(12, 6))
location_counts = data_swire_copy['PRODUCTION_LOCATION'].value_counts()
sns.barplot(x=location_counts.values, y=location_counts.index, palette='viridis')
plt.title('Breakdown Counts by Production Location')
plt.xlabel('Number of Breakdowns')
plt.ylabel('Production Location')
plt.tight_layout()
plt.show()

# Convert 'EXECUTION_START_DATE' to datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')

# Grouping breakdowns by year
breakdown_trends_yearly = data_swire_copy['EXECUTION_START_DATE'].groupby(data_swire_copy['EXECUTION_START_DATE'].dt.year).count()

# Plotting breakdown trends over time by year
plt.figure(figsize=(12, 6))
breakdown_trends_yearly.plot(kind='line', marker='o', color='b')
plt.title('Breakdown Trends Over Years')
plt.xlabel('Year')
plt.ylabel('Number of Breakdowns')
plt.xticks(breakdown_trends_yearly.index, rotation=45)

plt.tight_layout()
plt.show()

# Assuming 'EXECUTION_START_DATE' is already converted to datetime
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Filter data for a specific year
specific_year = 2023
data_specific_year = data_swire_copy[data_swire_copy['EXECUTION_START_DATE'].dt.year == specific_year]

# Grouping by month within the specific year
monthly_counts = data_specific_year['EXECUTION_START_DATE'].groupby(data_specific_year['EXECUTION_START_DATE'].dt.month).count()

# Plotting the number of maintenance activities per month in the specific year
monthly_counts.plot(kind='line', marker='o', figsize=(10, 6))
plt.title(f'Number of Maintenance Activities per Month in {specific_year}')
plt.xlabel('Month')
plt.ylabel('Number of Maintenance Activities')
plt.xticks(ticks=range(1, 13), labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
plt.tight_layout()
plt.show()

# Bar chart for MAINTENANCE_ACTIVITY_TYPE
plt.figure(figsize=(10, 6))
sns.countplot(x='MAINTENANCE_ACTIVITY_TYPE', data=data_swire_copy)
plt.title('Frequency of Maintenance Activity Type')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.ticklabel_format(style='plain', axis='y')
plt.show()

data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].value_counts()

# Grouping the data by MAINTENANCE_ACTIVITY_TYPE and calculating the mean of ACTUAL_WORK_IN_MINUTES
grouped_data = data_swire_copy.groupby('MAINTENANCE_ACTIVITY_TYPE')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Plotting the average downtime (ACTUAL_WORK_IN_MINUTES) for each Maintenance Activity Type
plt.figure(figsize=(12, 8))
bar_plot = sns.barplot(x='MAINTENANCE_ACTIVITY_TYPE', y='ACTUAL_WORK_IN_MINUTES', data=grouped_data, palette='viridis')

# Customizing the plot
plt.title('Average Downtime (Actual Work in Minutes) by Maintenance Activity Type')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Average Actual Work in Minutes')
plt.xticks(rotation=45)

# Adding values to each bar in the plot
for index, row in grouped_data.iterrows():
    bar_plot.text(index, row['ACTUAL_WORK_IN_MINUTES'], f'{row["ACTUAL_WORK_IN_MINUTES"]:.2f}',
                  ha='center', va='bottom', fontsize=10, color='black')

plt.tight_layout()
plt.show()

grouped_data = data_swire_copy.groupby('PLANT_ID')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Re-plotting as requested without numerical values and with red color bars
plt.figure(figsize=(12, 6))
bar_plot = sns.barplot(
    x='PLANT_ID',
    y='ACTUAL_WORK_IN_MINUTES',
    data=grouped_data,
    color='red',  # Use solid red color
    errorbar=None
)

# Customizing the plot
plt.title('Average Downtime by Plant', fontsize=14)
plt.xlabel('Plant ID', fontsize=12)
plt.ylabel('Average Actual Work in Minutes', fontsize=12)
plt.xticks(rotation=45, fontsize=10)
plt.yticks(fontsize=10)

# Adjust layout and show the plot
plt.tight_layout()
plt.show()

plt.figure(figsize=(12, 6))
count_plot = sns.countplot(x='MAINTENANCE_ACTIVITY_TYPE', hue='MAINTENANCE_TYPE_DESCRIPTION', data=data_swire_copy, palette='viridis')
plt.title('Count of Maintenance Type by Maintenance Activity Type')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Count')
plt.xticks(rotation=45)
for p in count_plot.patches:
    count_plot.annotate(format(p.get_height(), '.0f'),
                        (p.get_x() + p.get_width() / 2., p.get_height()),
                        ha='center', va='center', xytext=(0, 6), textcoords='offset points', fontsize=9, color='black')
plt.tight_layout()
plt.show()

print(data_swire_copy['FUNCTIONAL_AREA_NODE_4_MODIFIED'].value_counts())

FUNCTIONAL_AREA_NODE_4_MODIFIED
FILLER                      46322
PACKER                      35230
CONVEYOR                    34765
LABELER                     18945
PALLETIZER                  16239
                            ...  
MIXERS                          1
BATCH STATION METER SKID        1
G811 CONDENSATE RETURN          1
CIP TANK SKID                   1
CIP VALVE MATRIX SKID           1
Name: count, Length: 86, dtype: int64

print(data_swire_copy['FUNCTIONAL_AREA_NODE_5_MODIFIED'].value_counts())

FUNCTIONAL_AREA_NODE_5_MODIFIED
FULL CAN TO ACCUMULATION TABLE              251
PACKER 1, MODEL DUODOZEN 1250SX             210
FULL CASE CONVEYORS                         158
EMPTY CASE CONVEYORS                        136
FULL CASE SPIRAL TO PALLETIZER              125
FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT       114
EMPTY CAN                                   110
COMPRESSOR                                  110
PACKER 2, MODEL FENIX 185V                  108
FULL CASE CONVEYOR                          101
EAST SYRUP TANKS                             98
FULL BOTTLE CONVEYORS                        97
EMPTY CAN CONVEYOR                           90
*OLD SYSTEM MT CASE CONVEYORS*               56
LOOSE FB TO PACKER CONVEYORS                 52
FULL CAN CONVEYOR                            50
EVANS COOLING TUNNEL L3, INSIDE BUILDING     48
HARTNESS TO PAI FULL CASE CONVEYORS          47
PARTIAL CASES GPI (RIVERWOOD) TO DOUGLAS     43
INFEED TO HICONE TO PACKER                   33
EMPTY CAN VACUUM BLOWERS                     26
FULL CAN INFEED GPI                          24
DEPAL TO FILLER MT BOTTLE CONVEYORS          17
ACCUMULATION TABLES                          16
FULL CAN INFEED DOUGLAS/GPI (RIVERWOOD)      12
FULL CASE GPI (RIVERWOOD)                    10
FULL CASE FROM DOUGLAS TO PAI                 9
FULL CASE DOUGLAS                             7
PACK CONVEYOR                                 6
EVANS COOLING TUNNEL L3, OUTSIDE BUILDIN      5
CONVEYORS FOR PALLETIZER                      4
BLOWER SECTION #12 ACE-3-M112                 3
FB INFEED TO DOUGLAS CONVEYORS                1
BLOWER SECTION #1 ACE-3-M101                  1
BLOWER SECTION #11 ACE-3-M111                 1
PALLET CONVEYOR                               1
Name: count, dtype: int64

avg_downtime = data_swire_copy.groupby('FUNCTIONAL_AREA_NODE_4_MODIFIED')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

plt.figure(figsize=(12, 6))
sns.barplot(x='FUNCTIONAL_AREA_NODE_4_MODIFIED', y='ACTUAL_WORK_IN_MINUTES', data=avg_downtime, palette='viridis')
plt.title('Average Downtime by Functional Area Node 4')
plt.xlabel('Functional Area Node 4')
plt.ylabel('Average Actual Work in Minutes')
plt.xticks(rotation=90)
plt.show()

# Grouping the data by FUNCTIONAL_AREA_NODE_5_MODIFIED and calculating the average downtime (ACTUAL_WORK_IN_MINUTES)
average_downtime_node5 = data_swire_copy.groupby('FUNCTIONAL_AREA_NODE_5_MODIFIED')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Sorting the values for better visualization
average_downtime_node5 = average_downtime_node5.sort_values(by='ACTUAL_WORK_IN_MINUTES', ascending=False)

# Plotting the average downtime by Functional Area Node 5
plt.figure(figsize=(12, 8))
sns.barplot(x='ACTUAL_WORK_IN_MINUTES', y='FUNCTIONAL_AREA_NODE_5_MODIFIED', data=average_downtime_node5, palette='viridis')
plt.title('Average Downtime by Functional Area Node 5')
plt.xlabel('Average Actual Work in Minutes')
plt.ylabel('Functional Area Node 5')

for index, value in enumerate(average_downtime_node5['ACTUAL_WORK_IN_MINUTES']):
    plt.text(value, index, f'{value:.2f}', va='center', ha='left')

plt.tight_layout()
plt.show()

plt.figure(figsize=(12, 6))
count_plot = sns.countplot(x='EQUIP_CAT_DESC', hue='MAINTENANCE_TYPE_DESCRIPTION', data=data_swire_copy, palette='viridis')
plt.title('Frequency of Maintenance Type Across Equipment Categories')
plt.xlabel('Equipment Category')
plt.ylabel('Count')
plt.xticks(rotation=45)

# Adding values on top of each bar
for p in count_plot.patches:
    count_plot.annotate(format(p.get_height(), '.0f'),
                        (p.get_x() + p.get_width() / 2., p.get_height()),
                        ha='center', va='center', xytext=(0, 5), textcoords='offset points')

plt.tight_layout()
plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy['EQUIP_VALID_FROM'] = pd.to_datetime(data_swire_copy['EQUIP_VALID_FROM'], errors='coerce')

# Calculate equipment age in years
data_swire_copy['EQUIP_AGE'] = (data_swire_copy['EXECUTION_START_DATE'] - data_swire_copy['EQUIP_VALID_FROM']).dt.days / 365

# Filter for records where equipment age is greater than 0
filtered_data = data_swire_copy[data_swire_copy['EQUIP_AGE'] > 0]

# Scatter plot of equipment age vs actual work in minutes
plt.figure(figsize=(10, 6))
sns.scatterplot(x='EQUIP_AGE', y='ACTUAL_WORK_IN_MINUTES', data=filtered_data, alpha=0.6)
plt.title("Scatter Plot of Equipment Age vs Actual Work in Minutes")
plt.xlabel("Equipment Age (years)")
plt.ylabel("Actual Work in Minutes")
plt.show()

# Grouping data by MAINTENANCE_ACTIVITY_TYPE and PLANT_ID and calculating the mean of ACTUAL_WORK_IN_MINUTES
grouped_data = data_swire_copy.groupby(['MAINTENANCE_ACTIVITY_TYPE', 'PLANT_ID'])['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Plotting a bar plot with hue to differentiate plants
plt.figure(figsize=(12, 6))
sns.barplot(x='MAINTENANCE_ACTIVITY_TYPE', y='ACTUAL_WORK_IN_MINUTES', hue='PLANT_ID', data=grouped_data, palette='viridis')

# Customizing the plot
plt.title('Average Downtime by Maintenance Activity Type for Different Plants')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Average Actual Work in Minutes')
plt.xticks(rotation=45)
plt.legend(title='Plant ID')
plt.tight_layout()
plt.show()

# Filter for records where equipment age is greater than 0
filtered_data = data_swire_copy[data_swire_copy['EQUIP_AGE'] > 0]

# Scatter plot to visualize the relationship between equipment age and maintenance type
plt.figure(figsize=(10, 6))
sns.scatterplot(x='EQUIP_AGE', y='ACTUAL_WORK_IN_MINUTES', hue='MAINTENANCE_TYPE_DESCRIPTION', data=filtered_data, alpha=0.6, palette='viridis')
plt.title('Maintenance Type by Equipment Age and Downtime (Age > 0)')
plt.xlabel('Equipment Age (Years)')
plt.ylabel('Actual Work in Minutes')
plt.tight_layout()
plt.show()

# Calculate Q1  and Q3
Q1 = data_swire_copy['ACTUAL_WORK_IN_MINUTES'].quantile(0.25)
Q3 = data_swire_copy['ACTUAL_WORK_IN_MINUTES'].quantile(0.75)
IQR = Q3 - Q1

# Define lower and upper bounds for outliers
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# Identify outliers
outliers = data_swire_copy[(data_swire_copy['ACTUAL_WORK_IN_MINUTES'] < lower_bound) |
                           (data_swire_copy['ACTUAL_WORK_IN_MINUTES'] > upper_bound)]
print(f"Number of outliers: {len(outliers)}")

Number of outliers: 101066

# Remove outliers from the dataset
data_swire_copy_no_outliers = data_swire_copy[(data_swire_copy['ACTUAL_WORK_IN_MINUTES'] >= lower_bound) &
                                              (data_swire_copy['ACTUAL_WORK_IN_MINUTES'] <= upper_bound)]
print(f"Number of rows after removing outliers: {len(data_swire_copy_no_outliers)}")

Number of rows after removing outliers: 1326198

# Boxplot after handling outliers
plt.figure(figsize=(12, 6))
sns.boxplot(x=data_swire_copy['ACTUAL_WORK_IN_MINUTES'], palette='viridis')
plt.title('Boxplot of Actual Work in Minutes After Handling Outliers')
plt.xlabel('Actual Work in Minutes')
plt.show()

data_swire_copy.shape

(1427264, 26)

categories = {
    "FILLER": 0,
    "PACKER": 0,
    "LABELER": 0,
    "CAPPER": 0,
    "PALLETIZER": 0,
    "SEAMER": 0,
    "CONVEYOR": 0,
    "RINSER": 0,
    "WARMER": 0,
    "BLENDER": 0,
    "MIXER": 0,
    "TANK": 0,
    "PUMP": 0,
    "COMPRESSOR": 0,
    "CHILLER": 0,
    "BOILER": 0
}

# Convert EQUIPMENT_DESC to uppercase for case-insensitive matching
data_swire_copy['EQUIPMENT_DESC'] = data_swire_copy['EQUIPMENT_DESC'].str.upper()

# Count occurrences for each keyword
for key in categories.keys():
    categories[key] = data_swire_copy['EQUIPMENT_DESC'].str.contains(key, na=False).sum()

# Convert results to DataFrame
categories_df = pd.DataFrame(list(categories.items()), columns=['Equipment_Type', 'Count'])

# Display result
print(categories_df)

   Equipment_Type  Count
0          FILLER   8345
1          PACKER   2851
2         LABELER   5895
3          CAPPER     73
4      PALLETIZER   2512
5          SEAMER   3336
6        CONVEYOR    263
7          RINSER   2725
8          WARMER   1244
9         BLENDER     75
10          MIXER    639
11           TANK   1913
12           PUMP   1120
13     COMPRESSOR    239
14        CHILLER    132
15         BOILER    255

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Define keywords to identify equipment types
equipment_keywords = {
    'Filler': 'filler',
    'Packer': 'packer',
    'Blender': 'blender',
    'Blower': 'blower',
    'Labeler': 'labeler'
}

# Extract the necessary columns
equipment_info = data_swire_copy[['EQUIPMENT_ID', 'EQUIPMENT_DESC']].drop_duplicates()

# Initialize a new column for equipment type
equipment_info['Equipment_Type'] = np.nan

# Identify equipment type based on keywords in the description
for equipment_type, keyword in equipment_keywords.items():
    equipment_info.loc[equipment_info['EQUIPMENT_DESC'].str.contains(keyword, case=False, na=False), 'Equipment_Type'] = equipment_type

# Count occurrences of each EQUIPMENT_ID in the original data to measure breakdown frequency
breakdown_count = data_swire_copy['EQUIPMENT_ID'].value_counts().reset_index()
breakdown_count.columns = ['EQUIPMENT_ID', 'Breakdown_Count']

# Merge the breakdown count with the equipment information
equipment_summary = equipment_info.merge(breakdown_count, on='EQUIPMENT_ID', how='left')

# Filter out rows without identified equipment type (if you only want to see matched types)
equipment_summary = equipment_summary.dropna(subset=['Equipment_Type'])

# Rename columns for clarity
equipment_summary.rename(columns={'EQUIPMENT_ID': 'Equipment_ID', 'EQUIPMENT_DESC': 'Equipment_Description'}, inplace=True)

# Display the final table
final_output = equipment_summary[['Equipment_ID', 'Equipment_Description', 'Breakdown_Count', 'Equipment_Type']]
final_output

# Ensure the 'EXECUTION_START_DATE' column is in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')

# Extract the year from the 'EXECUTION_START_DATE' column
data_swire_copy['Year'] = data_swire_copy['EXECUTION_START_DATE'].dt.year

# Group by year and count the work orders for each year
yearly_work_orders = data_swire_copy.groupby('Year').size().reset_index(name='Work_Order_Count')

# Display the year-wise work order count
print(yearly_work_orders)

   Year  Work_Order_Count
0  2013                 1
1  2016             20925
2  2017            118305
3  2018            194641
4  2019            203767
5  2020            185807
6  2021            182353
7  2022            176190
8  2023            200874
9  2024            144401

# Load data with explicit datetime conversion
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')

# Drop any rows with NaT values in EXECUTION_START_DATE
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Hypothesis 1: Month-wise downtime patterns for each year
def monthly_downtime_by_year(data_swire_copy):
    # Extract year and month separately
    data_swire_copy['year'] = data_swire_copy['EXECUTION_START_DATE'].dt.year
    data_swire_copy['month'] = data_swire_copy['EXECUTION_START_DATE'].dt.month

    # Group by year and month, then count downtime instances
    downtime_counts = data_swire_copy.groupby(['year', 'month']).size().unstack(level=0)

    # Plot month-wise patterns for each year
    downtime_counts.plot(kind='line', figsize=(12, 6), marker='o')
    plt.title("Monthly Downtime Patterns for Each Year")
    plt.xlabel("Month")
    plt.ylabel("Downtime Count")
    plt.legend(title='Year')
    plt.show()

monthly_downtime_by_year(data_swire_copy)

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Extract year, month, week, and day of the week
data_swire_copy['year'] = data_swire_copy['EXECUTION_START_DATE'].dt.year
data_swire_copy['month'] = data_swire_copy['EXECUTION_START_DATE'].dt.month
data_swire_copy['week'] = data_swire_copy['EXECUTION_START_DATE'].dt.isocalendar().week
data_swire_copy['day_of_week'] = data_swire_copy['EXECUTION_START_DATE'].dt.day_name()

# Count downtime instances per day of the week for each week, month, and year
weekly_downtime = data_swire_copy.groupby(['year', 'month', 'week', 'day_of_week']).size().reset_index(name='downtime_count')

# Reorder day_of_week for proper plotting order
day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
weekly_downtime['day_of_week'] = pd.Categorical(weekly_downtime['day_of_week'], categories=day_order, ordered=True)

# Summarize downtime counts across all weeks, months, and years for each day of the week
downtime_summary = weekly_downtime.groupby('day_of_week')['downtime_count'].sum()

# Plot weekly downtime pattern, aggregated across all weeks, months, and years
plt.figure(figsize=(10, 6))
downtime_summary.plot(kind='bar', color='lightcoral')
plt.title("Weekly Downtime Pattern (Aggregated by All Weeks, Months, and Years)")
plt.xlabel("Day of the Week")
plt.ylabel("Total Downtime Count")
plt.xticks(rotation=45)
plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Extract year and day of the week
data_swire_copy['year'] = data_swire_copy['EXECUTION_START_DATE'].dt.year
data_swire_copy['day_of_week'] = data_swire_copy['EXECUTION_START_DATE'].dt.day_name()

# Count downtime instances per day of the week for each year
yearly_downtime = data_swire_copy.groupby(['year', 'day_of_week']).size().reset_index(name='downtime_count')

# Reorder day_of_week for consistent plotting order
day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
yearly_downtime['day_of_week'] = pd.Categorical(yearly_downtime['day_of_week'], categories=day_order, ordered=True)

# Loop through each year and plot downtime pattern for that year
for year in yearly_downtime['year'].unique():
    # Filter data for the specific year
    data_for_year = yearly_downtime[yearly_downtime['year'] == year].set_index('day_of_week').reindex(day_order).fillna(0)

    # Plot for the specific year
    plt.figure(figsize=(8, 5))
    data_for_year['downtime_count'].plot(kind='bar', color='skyblue')
    plt.title(f"Downtime Pattern by Day of the Week for {year}")
    plt.xlabel("Day of the Week")
    plt.ylabel("Downtime Count")
    plt.xticks(rotation=45)
    plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Sort data by machine and by date to calculate intervals
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time difference (in days) between consecutive failures for each machine
data_swire_copy['time_since_last_failure'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Drop any NaN values that result from the first failure in each machine's series
data_swire_copy = data_swire_copy.dropna(subset=['time_since_last_failure'])

# Calculate average MTBF over time by month or year (adjust as needed)
data_swire_copy['year_month'] = data_swire_copy['EXECUTION_START_DATE'].dt.to_period('M')  # Month-wise aggregation
mtbf_over_time = data_swire_copy.groupby('year_month')['time_since_last_failure'].mean()

# Plot MTBF over time
plt.figure(figsize=(12, 6))
mtbf_over_time.plot(kind='line', marker='o', color='blue')
plt.title("Mean Time Between Failures (MTBF) Over Time")
plt.xlabel("Year-Month")
plt.ylabel("Average MTBF (Days)")
plt.xticks(rotation=45)
plt.grid()
plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# 1. Daily, Weekly, and Monthly Aggregations

# Aggregate by day
daily_downtime = data_swire_copy.set_index('EXECUTION_START_DATE').resample('D').size()

# Aggregate by week
weekly_downtime = data_swire_copy.set_index('EXECUTION_START_DATE').resample('W').size()

# Aggregate by month
monthly_downtime = data_swire_copy.set_index('EXECUTION_START_DATE').resample('M').size()

# Plot daily, weekly, and monthly downtime trends
plt.figure(figsize=(15, 10))

plt.subplot(3, 1, 1)
daily_downtime.plot(color='blue')
plt.title("Daily Downtime Events")
plt.xlabel("Date")
plt.ylabel("Downtime Count")

plt.subplot(3, 1, 2)
weekly_downtime.plot(color='orange')
plt.title("Weekly Downtime Events")
plt.xlabel("Date")
plt.ylabel("Downtime Count")

plt.subplot(3, 1, 3)
monthly_downtime.plot(color='green')
plt.title("Monthly Downtime Events")
plt.xlabel("Date")
plt.ylabel("Downtime Count")

plt.tight_layout()
plt.show()

# 2. Day of the Week and Hourly Patterns

# Extract day of the week and hour for downtime events
data_swire_copy['day_of_week'] = data_swire_copy['EXECUTION_START_DATE'].dt.day_name()
data_swire_copy['hour_of_day'] = data_swire_copy['EXECUTION_START_DATE'].dt.hour

# Aggregate by day of the week
downtime_by_day = data_swire_copy['day_of_week'].value_counts().reindex(
    ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
)

# Aggregate by hour of the day
downtime_by_hour = data_swire_copy['hour_of_day'].value_counts().sort_index()

# Plot day of the week and hourly patterns
plt.figure(figsize=(15, 6))

plt.subplot(1, 2, 1)
downtime_by_day.plot(kind='bar', color='purple')
plt.title("Downtime Events by Day of the Week")
plt.xlabel("Day of the Week")
plt.ylabel("Downtime Count")

plt.subplot(1, 2, 2)
downtime_by_hour.plot(kind='bar', color='red')
plt.title("Downtime Events by Hour of the Day")
plt.xlabel("Hour of the Day")
plt.ylabel("Downtime Count")

plt.tight_layout()
plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# 1. Breakdown Frequency by Machine
machine_breakdowns = data_swire_copy['EQUIPMENT_ID'].value_counts()

# Plot breakdown frequency by machine (Top 10 machines)
plt.figure(figsize=(12, 6))
machine_breakdowns.head(10).plot(kind='bar', color='skyblue')
plt.title("Top 10 Machines with Most Breakdowns")
plt.xlabel("Machine ID")
plt.ylabel("Breakdown Count")
plt.show()

# 2. Mean Time Between Failures (MTBF) Calculation
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])
data_swire_copy['time_between_failures'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days
mtbf_per_machine = data_swire_copy.groupby('EQUIPMENT_ID')['time_between_failures'].mean()

# Plot MTBF for top 10 machines with the highest breakdown frequency
top_machines = machine_breakdowns.head(10).index
mtbf_top_machines = mtbf_per_machine[top_machines].dropna()

plt.figure(figsize=(12, 6))
mtbf_top_machines.plot(kind='bar', color='lightgreen')
plt.title("Mean Time Between Failures (MTBF) for Top 10 Machines")
plt.xlabel("Machine ID")
plt.ylabel("Average Days Between Failures")
plt.show()

# 3. Breakdown Distribution by Type and Cause
# Assuming 'MAINTENANCE_TYPE_DESCRIPTION' (corrective/preventive) and 'ORDER_DESCRIPTION' (description of cause) columns exist
breakdown_type_counts = data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'].value_counts()
cause_counts = data_swire_copy['ORDER_DESCRIPTION'].value_counts().head(10)

# Plot breakdowns by type and top 10 causes
plt.figure(figsize=(14, 6))

plt.subplot(1, 2, 1)
breakdown_type_counts.plot(kind='bar', color='coral')
plt.title("Breakdown Distribution by Maintenance Type")
plt.xlabel("Maintenance Type")
plt.ylabel("Count")

plt.subplot(1, 2, 2)
cause_counts.plot(kind='bar', color='salmon')
plt.title("Top 10 Breakdown Causes")
plt.xlabel("Cause Description")
plt.ylabel("Count")
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# 4. Temporal Breakdown Analysis (Monthly, Day of the Week, Hourly Patterns)
# Monthly breakdown pattern
data_swire_copy['year_month'] = data_swire_copy['EXECUTION_START_DATE'].dt.to_period('M')
monthly_breakdowns = data_swire_copy.groupby('year_month').size()
monthly_breakdowns.index = monthly_breakdowns.index.to_timestamp()

plt.figure(figsize=(12, 6))
monthly_breakdowns.plot(color='steelblue')
plt.title("Monthly Breakdown Pattern")
plt.xlabel("Month")
plt.ylabel("Breakdown Count")
plt.show()

# Day of the week pattern
data_swire_copy['day_of_week'] = data_swire_copy['EXECUTION_START_DATE'].dt.day_name()
dow_breakdowns = data_swire_copy['day_of_week'].value_counts().reindex(
    ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
)

plt.figure(figsize=(10, 5))
dow_breakdowns.plot(kind='bar', color='mediumpurple')
plt.title("Breakdowns by Day of the Week")
plt.xlabel("Day of the Week")
plt.ylabel("Breakdown Count")
plt.show()

# Hourly breakdown pattern
data_swire_copy['hour_of_day'] = data_swire_copy['EXECUTION_START_DATE'].dt.hour
hourly_breakdowns = data_swire_copy['hour_of_day'].value_counts().sort_index()

plt.figure(figsize=(10, 5))
hourly_breakdowns.plot(kind='bar', color='mediumseagreen')
plt.title("Breakdowns by Hour of the Day")
plt.xlabel("Hour of the Day")
plt.ylabel("Breakdown Count")
plt.show()

# Ensure EXECUTION_START_DATE is in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Extract month from EXECUTION_START_DATE
data_swire_copy['Month'] = data_swire_copy['EXECUTION_START_DATE'].dt.month

# Count breakdowns or maintenance activities by month
monthly_breakdowns = data_swire_copy.groupby('Month').size()

# Plotting the breakdown counts per month
plt.figure(figsize=(10, 6))
monthly_breakdowns.plot(kind='bar', color='skyblue')
plt.title('Maintenance Activities per Month (All Years Combined)')
plt.xlabel('Month')
plt.ylabel('Count of Maintenance Activities')
plt.xticks(ticks=range(0, 12), labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], rotation=45)

# Annotate counts on each bar
for index, value in enumerate(monthly_breakdowns):
    plt.text(index, value, str(value), ha='center', va='bottom')

plt.tight_layout()
plt.show()

# Display which month has the highest number of breakdowns
max_breakdown_month = monthly_breakdowns.idxmax()
max_breakdown_count = monthly_breakdowns.max()
print(f"The month with the highest breakdowns is: {max_breakdown_month} with {max_breakdown_count} activities.")

The month with the highest breakdowns is: 5 with 26547 activities.

# Ensure the date column is in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Group data by maintenance type and month without setting the index
monthly_counts_by_type = data_swire_copy.groupby([pd.Grouper(key='EXECUTION_START_DATE', freq='M'), 'MAINTENANCE_TYPE_DESCRIPTION']).size().unstack(fill_value=0)

# Plotting time series for each maintenance type
plt.figure(figsize=(14, 8))
monthly_counts_by_type.plot(ax=plt.gca(), linewidth=2)

# Adding title and labels
plt.title('Monthly Maintenance Events by Maintenance Type')
plt.xlabel('Date')
plt.ylabel('Number of Maintenance Events')
plt.legend(title='Maintenance Type Description')
plt.tight_layout()
plt.show()

# Calculate a 3-month rolling average for each maintenance type
rolling_avg_by_type = monthly_counts_by_type.rolling(window=3).mean()

# Plotting the rolling average for each maintenance type
plt.figure(figsize=(14, 8))
rolling_avg_by_type.plot(ax=plt.gca(), linewidth=2)

# Adding title and labels
plt.title('3-Month Rolling Average of Maintenance Events by Maintenance Type')
plt.xlabel('Date')
plt.ylabel('Average Number of Maintenance Events')
plt.legend(title='Maintenance Type Description')
plt.tight_layout()
plt.show()

work_orders_by_plant_machine = data_swire_copy.groupby(['PLANT_ID', 'EQUIPMENT_ID']).agg(
    work_order_count=('ORDER_ID', 'count')
).reset_index()

# Display aggregated data
print("Aggregated Work Orders by Plant and Machine:")
print(work_orders_by_plant_machine)

# Aggregating work orders by plant and equipment category
work_orders_by_plant_category = data_swire_copy.groupby(['PLANT_ID', 'EQUIP_CAT_DESC']).agg(
    work_order_count=('ORDER_ID', 'count')
).reset_index()

print("\nAggregated Work Orders by Plant and Equipment Category:")
print(work_orders_by_plant_category)

# Optional: Aggregating work orders by plant, machine, and year if EXECUTION_START_DATE is available
if 'EXECUTION_START_DATE' in data_swire_copy.columns:
    data_swire_copy['EXECUTION_YEAR'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE']).dt.year
    work_orders_by_plant_machine_year = data_swire_copy.groupby(['PLANT_ID', 'EQUIPMENT_ID', 'EXECUTION_YEAR']).agg(
        work_order_count=('ORDER_ID', 'count')
    ).reset_index()

    print("\nAggregated Work Orders by Plant, Machine, and Year:")
    print(work_orders_by_plant_machine_year)

# Additional aggregations such as total downtime (if a downtime column is available)
if 'ACTUAL_WORK_IN_MINUTES' in data_swire_copy.columns:
    downtime_by_plant_machine = data_swire_copy.groupby(['PLANT_ID', 'EQUIPMENT_ID']).agg(
        total_downtime=('ACTUAL_WORK_IN_MINUTES', 'sum'),
        avg_downtime=('ACTUAL_WORK_IN_MINUTES', 'mean')
    ).reset_index()

    print("\nDowntime Aggregation by Plant and Machine:")
    print(downtime_by_plant_machine)

Aggregated Work Orders by Plant and Machine:
     PLANT_ID  EQUIPMENT_ID  work_order_count
0        G221   300009071.0                62
1        G221   300009072.0                27
2        G221   300009073.0                 6
3        G221   300009074.0               115
4        G221   300009075.0                54
...       ...           ...               ...
2533     G816   400017400.0                 1
2534     G816   400017600.0                37
2535     G816   400022400.0                 4
2536     G816   400027400.0                36
2537     G816   400027800.0                 3

[2538 rows x 3 columns]

Aggregated Work Orders by Plant and Equipment Category:
   PLANT_ID              EQUIP_CAT_DESC  work_order_count
0      G221                    Machines               357
1      G221           Plant & Buildings                49
2      G221  Test/measurement equipment                 4
3      G261                    Machines              1742
4      G291                    Machines             54953
5      G291           Plant & Buildings                 4
6      G291  Production resources/tools                74
7      G811                    Machines              3411
8      G811           Plant & Buildings                12
9      G811  Test/measurement equipment                 2
10     G812                    Machines              5119
11     G816                    Machines             12823
12     G816  Test/measurement equipment                47

Aggregated Work Orders by Plant, Machine, and Year:
      PLANT_ID  EQUIPMENT_ID  EXECUTION_YEAR  work_order_count
0         G221   300009071.0            2017                 6
1         G221   300009071.0            2018                11
2         G221   300009071.0            2019                 8
3         G221   300009071.0            2020                10
4         G221   300009071.0            2021                 7
...        ...           ...             ...               ...
11618     G816   400027400.0            2022                 8
11619     G816   400027400.0            2023                16
11620     G816   400027400.0            2024                12
11621     G816   400027800.0            2022                 1
11622     G816   400027800.0            2023                 2

[11623 rows x 4 columns]

Downtime Aggregation by Plant and Machine:
     PLANT_ID  EQUIPMENT_ID  total_downtime  avg_downtime
0        G221   300009071.0          4090.2     65.970968
1        G221   300009072.0          2505.6     92.800000
2        G221   300009073.0          1490.4    248.400000
3        G221   300009074.0          8294.4     72.125217
4        G221   300009075.0          5007.0     92.722222
...       ...           ...             ...           ...
2533     G816   400017400.0            19.8     19.800000
2534     G816   400017600.0          2232.0     60.324324
2535     G816   400022400.0           270.0     67.500000
2536     G816   400027400.0          2118.0     58.833333
2537     G816   400027800.0            36.0     12.000000

[2538 rows x 4 columns]

import matplotlib.pyplot as plt

# Define the functional nodes columns to analyze
functional_nodes = [
    'FUNCTIONAL_AREA_NODE_1_MODIFIED',
    'FUNCTIONAL_AREA_NODE_2_MODIFIED',
    'FUNCTIONAL_AREA_NODE_3_MODIFIED',
    'FUNCTIONAL_AREA_NODE_4_MODIFIED',
    'FUNCTIONAL_AREA_NODE_5_MODIFIED'
]

# Loop through each functional node column
for node in functional_nodes:
    # Count occurrences of each unique value in the node column
    node_counts = data_swire_copy[node].value_counts()

    # Filter to show only values that appear more than once (repeated entries)
    repeated_node = node_counts[node_counts > 1]

    # Plotting the repeated entries as a bar plot
    plt.figure(figsize=(12, 8))
    repeated_node.plot(kind='bar', color='skyblue')
    plt.title(f'Repeated Entries in {node}')
    plt.xlabel(node)
    plt.ylabel('Count')
    plt.xticks(rotation=45, ha='right')
    plt.tight_layout()
    plt.show()

# Calculate counts for different maintenance types in unplanned activities
corrective_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Corrective Maintenance Order')
].shape[0]

preventive_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Preventive Maintenance Order')
].shape[0]

capital_order_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Capital Order')
].shape[0]

breakdown_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Breakdown Maintenance Order')
].shape[0]

administrative_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Administrative Order')
].shape[0]

# Print results
print(f"Number of corrective maintenance orders in unplanned activities: {corrective_unplanned_count}")
print(f"Number of preventive maintenance orders in unplanned activities: {preventive_unplanned_count}")
print(f"Number of capital orders in unplanned activities: {capital_order_unplanned_count}")
print(f"Number of breakdown orders in unplanned activities: {breakdown_unplanned_count}")
print(f"Number of administrative orders in unplanned activities: {administrative_unplanned_count}")

Number of corrective maintenance orders in unplanned activities: 132084
Number of preventive maintenance orders in unplanned activities: 1146
Number of capital orders in unplanned activities: 21
Number of breakdown orders in unplanned activities: 5
Number of administrative orders in unplanned activities: 6097

maintenance_patterns = data_swire_copy.groupby(['FUNCTIONAL_AREA_NODE_1_MODIFIED', 'MAINTENANCE_TYPE_DESCRIPTION','PRODUCTION_LOCATION']).size().unstack(fill_value=0)

# Plotting the heatmap
plt.figure(figsize=(12, 8))
sns.heatmap(maintenance_patterns, annot=True, fmt="d", cmap="YlGnBu", linewidths=0.5)

# Customizing the plot
plt.title('Heatmap of Maintenance Type Patterns by Functional Area Node 1')
plt.xlabel('Maintenance Type Description')
plt.ylabel('Functional Area Node 1')

# Show the plot
plt.tight_layout()
plt.show()

# Ensure date columns are in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'])

# Sort data by EQUIPMENT_DESC and EXECUTION_START_DATE
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_DESC', 'EXECUTION_START_DATE'])

# Calculate time between failures in hours
data_swire_copy['Time_Between_Failures'] = data_swire_copy.groupby('EQUIPMENT_DESC')['EXECUTION_START_DATE'].diff().dt.total_seconds() / 3600

# Remove rows where time between failures is NaN (first occurrence for each equipment)
data_swire_copy = data_swire_copy.dropna(subset=['Time_Between_Failures'])

# Filter top 10 equipment types by frequency
top_10_equipment = data_swire_copy['EQUIPMENT_DESC'].value_counts().nlargest(10).index
top_10_data = data_swire_copy[data_swire_copy['EQUIPMENT_DESC'].isin(top_10_equipment)]

# Plot density plots for the top 10 equipment types
fig, axes = plt.subplots(5, 2, figsize=(15, 15), constrained_layout=True)  # Adjust layout for 10 plots (5 rows, 2 columns)
axes = axes.flatten()

for ax, equipment in zip(axes, top_10_equipment):
    sns.kdeplot(
        data=top_10_data[top_10_data['EQUIPMENT_DESC'] == equipment]['Time_Between_Failures'],
        fill=True,
        color="salmon",
        ax=ax
    )
    ax.set_title(equipment)
    ax.set_xlabel("Time Between Failures [Hours]")
    ax.set_ylabel("Density")

plt.show()

equipment_categories = [
    "FILLER", "PACKER", "LABELER", "CAPPER", "PALLETIZER", "SEAMER",
    "CONVEYOR", "RINSER", "WARMER", "BLENDER", "MIXER", "TANK",
    "PUMP", "COMPRESSOR", "CHILLER", "BOILER"
]

# Create a column to classify each entry in data by equipment category
data_swire_copy['Equipment_Category'] = data_swire_copy['EQUIPMENT_DESC'].apply(
    lambda x: next((cat for cat in equipment_categories if cat in x), 'Other')
)

# Filter the data for the relevant equipment categories only
filtered_data = data_swire_copy[data_swire_copy['Equipment_Category'].isin(equipment_categories)]

# Plot density for each equipment category
fig, axes = plt.subplots(4, 4, figsize=(20, 15), constrained_layout=True)  # 4x4 grid for 16 categories
axes = axes.flatten()

for ax, category in zip(axes, equipment_categories):
    sns.kdeplot(
        data=filtered_data[filtered_data['Equipment_Category'] == category]['Time_Between_Failures'],
        fill=True,
        color="salmon",
        ax=ax
    )
    ax.set_title(category)
    ax.set_xlabel("Time Between Failures [Hours]")
    ax.set_ylabel("Density")

plt.show()

# Calculate maintenance frequency and average downtime for each node
maintenance_patterns = data_swire_copy.groupby(['FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
                                                'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED',
                                                'FUNCTIONAL_AREA_NODE_5_MODIFIED'])['ACTUAL_WORK_IN_MINUTES'] \
                                       .agg(['count', 'mean']).reset_index()

maintenance_patterns.rename(columns={'count': 'Maintenance_Frequency', 'mean': 'Average_Downtime'}, inplace=True)

# Sort by Maintenance_Frequency and Average_Downtime in descending order
high_maintenance_areas = maintenance_patterns.sort_values(by=['Maintenance_Frequency', 'Average_Downtime'], ascending=False)

# Reset the index to have a clean ordered index
high_maintenance_areas.reset_index(drop=True, inplace=True)


high_maintenance_areas.head(10)

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Filter for planned maintenance events
planned_maintenance = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned']

# Extract year from the execution date for year-wise aggregation
planned_maintenance['year'] = planned_maintenance['EXECUTION_START_DATE'].dt.year

# Calculate the yearly count of planned maintenance events for each machine
yearly_maintenance_by_machine = planned_maintenance.groupby(['EQUIPMENT_ID', 'year']).size().unstack(fill_value=0)

# Plot year-wise planned maintenance count for the top 10 machines with the most events overall
top_machines = yearly_maintenance_by_machine.sum(axis=1).sort_values(ascending=False).head(10).index
yearly_maintenance_top_machines = yearly_maintenance_by_machine.loc[top_machines]

yearly_maintenance_top_machines

# Ensure datetime conversion and remove rows with invalid dates
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Filter for planned maintenance events and create a copyD
planned_maintenance = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned'].copy()

# Sort by EQUIPMENT_ID and EXECUTION_START_DATE to compute time intervals between events
planned_maintenance = planned_maintenance.sort_values(['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time difference between consecutive planned maintenance events for each machine
planned_maintenance['Maintenance_Interval_Days'] = planned_maintenance.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Calculate the average maintenance interval (in days) for each machine
maintenance_frequency = planned_maintenance.groupby('EQUIPMENT_ID')['Maintenance_Interval_Days'].mean().dropna()

# Convert the frequency to weeks for easier interpretation
maintenance_frequency_weeks = maintenance_frequency / 7

# Display the maintenance frequency in both days and weeks for the top 10 machines
top_machines = maintenance_frequency.sort_values(ascending=True)  # Top 10 machines with shortest average intervals
top_machines_weeks = maintenance_frequency_weeks[top_machines.index]

# Create a DataFrame to display the results
frequency_df = pd.DataFrame({
    'Average_Interval_Days': top_machines,
    'Average_Interval_Weeks': top_machines_weeks
})

frequency_df

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Sort data by machine and by date
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time difference (in days) between consecutive failures for each machine
data_swire_copy['time_between_failures'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Calculate breakdown count and MTBF (Mean Time Between Failures) for each machine
breakdown_count = data_swire_copy['EQUIPMENT_ID'].value_counts()
mtbf_per_machine = data_swire_copy.groupby('EQUIPMENT_ID')['time_between_failures'].mean()

# Define risk thresholds
# High breakdown count threshold (top 10%)
breakdown_threshold = breakdown_count.quantile(0.9)

# Short MTBF threshold (bottom 10% of MTBF)
mtbf_threshold = mtbf_per_machine.quantile(0.1)

# Create a risk assessment table
risk_table = pd.DataFrame({
    'Breakdown_Count': breakdown_count,
    'Average_MTBF_Days': mtbf_per_machine
})

# Determine risk status based on thresholds
risk_table['Risk_Status'] = risk_table.apply(
    lambda row: 'At Risk' if (row['Breakdown_Count'] >= breakdown_threshold) or
                                (row['Average_MTBF_Days'] <= mtbf_threshold) else 'Low Risk', axis=1
)

# Sort the at-risk equipment by Breakdown Count and Average MTBF in descending order
# and display the top 10 entries
at_risk_equipments = risk_table[risk_table['Risk_Status'] == 'At Risk']
top_10_at_risk_equipments = at_risk_equipments.sort_values(
    by=['Breakdown_Count', 'Average_MTBF_Days'],
    ascending=[False, True]  # Sorting by highest breakdowns and shortest MTBF
).head(10)

# Reset index for a clean display
top_10_at_risk_equipments.reset_index().rename(columns={'index': 'Equipment_ID'}, inplace=True)

# Display the top 10 at-risk equipment
print(top_10_at_risk_equipments)

              Breakdown_Count  Average_MTBF_Days Risk_Status
EQUIPMENT_ID                                                
300115000.0              3743           0.476750     At Risk
300001113.0              2736           0.998537     At Risk
300001510.0              2509           1.088118     At Risk
300001505.0              2070           1.320445     At Risk
300001078.0              1851           1.473514     At Risk
300001276.0              1574           1.736173     At Risk
300001133.0              1534           1.778213     At Risk
300001509.0              1472           1.850442     At Risk
300001580.0              1470           1.855003     At Risk
300001248.0              1318           2.065300     At Risk

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Sort data by machine and date to calculate time intervals
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time (in days) between consecutive downtime events (MTBF approximation)
data_swire_copy['time_between_failures'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Estimate production rate based on MTBF (assume output is proportional to operational time)
# Here, we assume each day in "time_between_failures" translates to a certain production rate, e.g., 100 cases/day
production_rate_per_day = 100  # Assumed rate, can be adjusted

# Calculate effective production per machine by multiplying MTBF by production rate
mtbf_per_machine = data_swire_copy.groupby('EQUIPMENT_ID')['time_between_failures'].mean()
estimated_production_per_machine = mtbf_per_machine * production_rate_per_day

# Calculate total estimated demand (sum of production across machines)
estimated_total_demand = estimated_production_per_machine.sum()

# Display results
production_capacity_table = pd.DataFrame({
    'Average_MTBF_Days': mtbf_per_machine,
    'Estimated_Production_Per_Machine': estimated_production_per_machine
})

print("Estimated Production Capacity per Machine:")
print(production_capacity_table)
print(f"\nEstimated Total Daily Demand: {estimated_total_demand}")

Estimated Production Capacity per Machine:
              Average_MTBF_Days  Estimated_Production_Per_Machine
EQUIPMENT_ID                                                     
300001001.0           32.405063                       3240.506329
300001002.0            6.037611                        603.761062
300001003.0            3.991189                        399.118943
300001004.0            7.880466                        788.046647
300001005.0           31.309524                       3130.952381
...                         ...                               ...
400016000.0            0.000000                          0.000000
400022400.0          320.000000                      32000.000000
400027400.0           21.911765                       2191.176471
400027800.0           84.000000                       8400.000000
400028001.0           57.500000                       5750.000000

[607 rows x 2 columns]

Estimated Total Daily Demand: 4412889.511369938

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Sort data by machine and by date
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Filter for planned maintenance and unplanned downtime events
planned_maintenance = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned']
unplanned_downtime = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned']

# Calculate the time between each planned maintenance and the next unplanned downtime for each machine
maintenance_intervals = []

for equipment_id in planned_maintenance['EQUIPMENT_ID'].unique():
    # Filter events for the specific machine
    machine_maintenance = planned_maintenance[planned_maintenance['EQUIPMENT_ID'] == equipment_id]
    machine_downtime = unplanned_downtime[unplanned_downtime['EQUIPMENT_ID'] == equipment_id]

    # Loop through each maintenance event
    for maintenance_date in machine_maintenance['EXECUTION_START_DATE']:
        # Find the next unplanned downtime after each maintenance
        next_downtime = machine_downtime[machine_downtime['EXECUTION_START_DATE'] > maintenance_date]

        if not next_downtime.empty:
            time_to_next_downtime = (next_downtime['EXECUTION_START_DATE'].iloc[0] - maintenance_date).days
            maintenance_intervals.append({'EQUIPMENT_ID': equipment_id, 'maintenance_date': maintenance_date, 'time_to_next_downtime': time_to_next_downtime})

# Create a DataFrame to analyze maintenance intervals
maintenance_intervals_df = pd.DataFrame(maintenance_intervals)

# Calculate average time to next downtime after maintenance for each machine
avg_time_to_downtime = maintenance_intervals_df.groupby('EQUIPMENT_ID')['time_to_next_downtime'].mean()

# Plot average time to next downtime after maintenance for each machine
# Plot histogram of average time to next downtime
plt.figure(figsize=(10, 6))
plt.hist(avg_time_to_downtime, bins=20, color='lightgreen', edgecolor='black')
plt.title("Histogram of Average Time to Next Downtime After Maintenance")
plt.xlabel("Average Days to Next Downtime")
plt.ylabel("Number of Machines")
plt.show()

top_machines = avg_time_to_downtime.sort_values(ascending=False).head(10)

# Plot top 10 machines
plt.figure(figsize=(10, 6))
top_machines.plot(kind='bar', color='skyblue')
plt.title("Top 10 Machines with Longest Average Time to Next Downtime After Maintenance")
plt.xlabel("Machine ID")
plt.ylabel("Average Days to Next Downtime")
plt.xticks(rotation=45)
plt.show()

# Ensure the date column is in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Group by month and count maintenance events each month
monthly_maintenance = data_swire_copy.set_index('EXECUTION_START_DATE').resample('M').size()

# Decompose the time series into trend, seasonal, and residual components
decomposition = seasonal_decompose(monthly_maintenance, model='additive', period=12)  # period=12 for monthly seasonality in a year

# Plot each component
plt.figure(figsize=(12, 10))

plt.subplot(4, 1, 1)
plt.plot(monthly_maintenance, label='Original')
plt.legend(loc='best')

plt.subplot(4, 1, 2)
plt.plot(decomposition.trend, label='Trend', color='blue')
plt.legend(loc='best')

plt.subplot(4, 1, 3)
plt.plot(decomposition.seasonal, label='Seasonality', color='green')
plt.legend(loc='best')

plt.subplot(4, 1, 4)
plt.plot(decomposition.resid, label='Residuals', color='red')
plt.legend(loc='best')

plt.tight_layout()
plt.show()

# Define seasons based on 'EXECUTION_FINISH_DATE'
# Define cost per minute
cost_per_minute = 8.33  # Adjust this value based on actual cost

# Calculate downtime cost
data_swire_copy['downtime_cost'] = data_swire_copy['ACTUAL_WORK_IN_MINUTES'] * cost_per_minute

data_swire_copy['season'] = data_swire_copy['EXECUTION_FINISH_DATE'].dt.month % 12 // 3 + 1  # 1=Winter, 2=Spring, etc.
season_labels = {1: "Winter", 2: "Spring", 3: "Summer", 4: "Fall"}

# Calculate total downtime cost per season
seasonal_downtime_cost = data_swire_copy.groupby('season')['downtime_cost'].sum().rename(index=season_labels)
print("Total Downtime Cost by Season:")
print(seasonal_downtime_cost)

# Plot downtime costs by season
seasonal_downtime_cost.plot(kind='bar', color='skyblue')
plt.title("Total Downtime Cost by Season")
plt.xlabel("Season")
plt.ylabel("Downtime Cost ($)")
plt.xticks(rotation=45)
plt.grid(True)
plt.show()

Total Downtime Cost by Season:
season
Winter    1.006564e+07
Spring    1.375680e+07
Summer    1.344350e+07
Fall      9.404182e+06
Name: downtime_cost, dtype: float64

# Ensure the date column is in datetime format
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'], errors='coerce')

# Extract the month from the date column
data_swire_copy['month'] = data_swire_copy['EXECUTION_FINISH_DATE'].dt.month

# Calculate total downtime cost per month
monthly_downtime_cost = data_swire_copy.groupby('month')['downtime_cost'].sum()

# Display the month-wise downtime costs
print(monthly_downtime_cost)

# Plot month-wise downtime cost
plt.figure(figsize=(10, 6))
monthly_downtime_cost.plot(kind='bar', color='skyblue')
plt.title("Total Downtime Cost by Month")
plt.xlabel("Month")
plt.ylabel("Downtime Cost ($)")
plt.xticks(ticks=range(12), labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], rotation=45)
plt.grid(True)
plt.tight_layout()
plt.show()

month
1     3333526.056
2     3528742.938
3     4445191.212
4     4503637.824
5     4807971.042
6     4579432.494
7     4321865.562
8     4542197.394
9     3005317.392
10    3141957.714
11    3256906.716
12    3203369.806
Name: downtime_cost, dtype: float64

# Define average downtime cost per hour (example: $500 per hour)
avg_cost_per_hour = 500

# Convert 'ACTUAL_WORK_IN_MINUTES' to hours for cost calculation
data_swire_copy['maintenance_duration_hours'] = data_swire_copy['ACTUAL_WORK_IN_MINUTES'] / 60

# Calculate the opportunity cost based on downtime hours
data_swire_copy['downtime_cost'] = data_swire_copy['maintenance_duration_hours'] * avg_cost_per_hour

# Summarize total downtime cost by functional node or other relevant categories
downtime_cost_summary = data_swire_copy.groupby('FUNCTIONAL_AREA_NODE_1_MODIFIED')['downtime_cost'].sum()

# Set display options for better readability
pd.options.display.float_format = '{:,.2f}'.format
print("Total Downtime Cost by Functional Node:")
print(downtime_cost_summary)

Total Downtime Cost by Functional Node:
FUNCTIONAL_AREA_NODE_1_MODIFIED
COTA PRODUCTION           9,442,035.00
MONZA PRODUCTION         26,783,016.67
PRODUCTION                7,547,925.00
SILVERSTONE PRODUCTION    1,855,500.00
SUZUKA PRODUCTION           511,270.00
Name: downtime_cost, dtype: float64

# Define the feature columns and target column
X = data_swire_copy[['MAINTENANCE_TYPE_DESCRIPTION', 'PRODUCTION_LOCATION', 'FUNCTIONAL_LOC']]
y = data_swire_copy['ACTUAL_WORK_IN_MINUTES']

# Split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Define preprocessing for categorical features
preprocessor = ColumnTransformer(
    transformers=[
        ('cat', OneHotEncoder(handle_unknown='ignore'), ['MAINTENANCE_TYPE_DESCRIPTION', 'PRODUCTION_LOCATION', 'FUNCTIONAL_LOC'])
    ])

# Create a pipeline that combines preprocessing and model
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('model', RandomForestRegressor(n_estimators=100, random_state=42))
])

# Train the model
pipeline.fit(X_train, y_train)

# Make predictions and evaluate
y_pred = pipeline.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
print("Mean Absolute Error:", mae)
print("Mean Squared Error:", mse)

# Feature Importance (for Random Forest)
importances = pipeline.named_steps['model'].feature_importances_
feature_names = pipeline.named_steps['preprocessor'].transformers_[0][1].get_feature_names_out()
feature_importances = pd.Series(importances, index=feature_names).sort_values(ascending=False)
print("Top Features:")
feature_importances.head(10)

feature_importances.head(10).plot(kind='barh', color='skyblue')
plt.title("Top Feature Importances for Downtime Prediction")
plt.xlabel("Importance")
plt.show()

Mean Absolute Error: 50.732367710435256
Mean Squared Error: 12871.74305811443
Top Features:

desc_text = data_swire_copy['ORDER_DESCRIPTION'].str.cat(sep=' ')

wc = WordCloud(background_color='black', colormap = 'binary').generate(desc_text)
plt.imshow(wc)

<matplotlib.image.AxesImage at 0x7e57a615ca30>

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Resample the data to a time series format
time_series_data = data_swire_copy.set_index('EXECUTION_START_DATE').resample('D').size().reset_index(name='count')

# Split the data into training and testing sets
train_size = int(len(time_series_data) * 0.8)
train_y, test_y = time_series_data['count'][:train_size], time_series_data['count'][train_size:]
test_dates = time_series_data['EXECUTION_START_DATE'][train_size:]

# auto_ARIMA to find the best parameters
model_auto_arima = auto_arima(train_y, seasonal=False, stepwise=True, trace=True, error_action='ignore', suppress_warnings=True)
print(f"Best model: {model_auto_arima.order}")

# Fit the ARIMA model with the best parameters
model = ARIMA(train_y, order=model_auto_arima.order)
model_fit = model.fit()

# Forecast future values for the test set
predictions = model_fit.forecast(steps=len(test_y))

# Evaluate the model
rmse = np.sqrt(mean_squared_error(test_y, predictions))
print('Test RMSE:', rmse)

# Plot the results
plt.figure(figsize=(12, 6))
plt.plot(time_series_data['EXECUTION_START_DATE'][:train_size], train_y, label='Training Data', color='blue')
plt.plot(test_dates, test_y, label='Testing Data', color='orange')
plt.plot(test_dates, predictions, label='Predictions', color='red')
plt.legend()
plt.title('ARIMA Time Series Analysis')
plt.xlabel('Date')
plt.ylabel('Number of Maintenance Activities')
plt.show()

Performing stepwise search to minimize aic
 ARIMA(2,1,2)(0,0,0)[0] intercept   : AIC=39752.188, Time=5.22 sec
 ARIMA(0,1,0)(0,0,0)[0] intercept   : AIC=42280.376, Time=0.11 sec
 ARIMA(1,1,0)(0,0,0)[0] intercept   : AIC=42236.805, Time=0.16 sec
 ARIMA(0,1,1)(0,0,0)[0] intercept   : AIC=42116.562, Time=0.93 sec
 ARIMA(0,1,0)(0,0,0)[0]             : AIC=42278.380, Time=0.08 sec
 ARIMA(1,1,2)(0,0,0)[0] intercept   : AIC=40545.764, Time=8.35 sec
 ARIMA(2,1,1)(0,0,0)[0] intercept   : AIC=40146.430, Time=3.16 sec
 ARIMA(3,1,2)(0,0,0)[0] intercept   : AIC=40116.245, Time=9.08 sec
 ARIMA(2,1,3)(0,0,0)[0] intercept   : AIC=inf, Time=9.82 sec
 ARIMA(1,1,1)(0,0,0)[0] intercept   : AIC=41955.414, Time=1.75 sec
 ARIMA(1,1,3)(0,0,0)[0] intercept   : AIC=40552.691, Time=11.12 sec
 ARIMA(3,1,1)(0,0,0)[0] intercept   : AIC=40085.166, Time=5.82 sec
 ARIMA(3,1,3)(0,0,0)[0] intercept   : AIC=inf, Time=13.52 sec
 ARIMA(2,1,2)(0,0,0)[0]             : AIC=39751.330, Time=1.83 sec
 ARIMA(1,1,2)(0,0,0)[0]             : AIC=40547.846, Time=2.00 sec
 ARIMA(2,1,1)(0,0,0)[0]             : AIC=40148.500, Time=3.72 sec
 ARIMA(3,1,2)(0,0,0)[0]             : AIC=inf, Time=5.84 sec
 ARIMA(2,1,3)(0,0,0)[0]             : AIC=inf, Time=5.36 sec
 ARIMA(1,1,1)(0,0,0)[0]             : AIC=41953.417, Time=1.00 sec
 ARIMA(1,1,3)(0,0,0)[0]             : AIC=40523.084, Time=6.46 sec
 ARIMA(3,1,1)(0,0,0)[0]             : AIC=40086.987, Time=2.06 sec
 ARIMA(3,1,3)(0,0,0)[0]             : AIC=39160.040, Time=4.26 sec
 ARIMA(4,1,3)(0,0,0)[0]             : AIC=37997.016, Time=6.70 sec
 ARIMA(4,1,2)(0,0,0)[0]             : AIC=38269.563, Time=7.01 sec
 ARIMA(5,1,3)(0,0,0)[0]             : AIC=37541.256, Time=5.04 sec
 ARIMA(5,1,2)(0,0,0)[0]             : AIC=37659.624, Time=11.61 sec
 ARIMA(5,1,4)(0,0,0)[0]             : AIC=37302.760, Time=17.91 sec
 ARIMA(4,1,4)(0,0,0)[0]             : AIC=inf, Time=14.95 sec
 ARIMA(5,1,5)(0,0,0)[0]             : AIC=inf, Time=12.31 sec
 ARIMA(4,1,5)(0,0,0)[0]             : AIC=37621.240, Time=6.67 sec
 ARIMA(5,1,4)(0,0,0)[0] intercept   : AIC=37306.757, Time=16.53 sec

Best model:  ARIMA(5,1,4)(0,0,0)[0]          
Total fit time: 200.475 seconds
Best model: (5, 1, 4)

/usr/local/lib/python3.10/dist-packages/statsmodels/base/model.py:607: ConvergenceWarning: Maximum Likelihood optimization failed to converge. Check mle_retvals
  warnings.warn("Maximum Likelihood optimization failed to "

Test RMSE: 210.78868210140388

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Set the datetime column as the index
data_swire_copy.set_index('EXECUTION_START_DATE', inplace=True)

# Resample the data to a time series format
time_series_data = data_swire_copy.resample('D').size()

# Plot the time series
plt.figure(figsize=(12, 6))
plt.plot(time_series_data, label='Number of Maintenance Activities per Day')
plt.title('Time Series of Maintenance Activities')
plt.xlabel('Date')
plt.ylabel('Number of Activities')
plt.legend()
plt.show()

# Fit an ARIMA model
# Use auto_ARIMA to find the best p, d, q parameters
model_auto_arima = auto_arima(time_series_data, seasonal=False, stepwise=True, trace=True)

# Print the best parameters
print(f"Best model: {model_auto_arima.order}")

# Fit the ARIMA model with the best parameters
model = ARIMA(time_series_data, order=model_auto_arima.order)
model_fit = model.fit()

# Print model summary
print(model_fit.summary())

# Forecast future values
forecast = model_fit.forecast(steps=30)  # Forecast for the next 30 days

# Plot the forecast
plt.figure(figsize=(12, 6))
plt.plot(time_series_data, label='Observed')
plt.plot(forecast, label='Forecast', color='red')
plt.title('ARIMA Model Forecast')
plt.xlabel('Date')
plt.ylabel('Number of Activities')
plt.legend()
plt.show()

Performing stepwise search to minimize aic
 ARIMA(2,1,2)(0,0,0)[0] intercept   : AIC=50417.730, Time=8.34 sec
 ARIMA(0,1,0)(0,0,0)[0] intercept   : AIC=53658.438, Time=0.13 sec
 ARIMA(1,1,0)(0,0,0)[0] intercept   : AIC=53603.376, Time=0.17 sec
 ARIMA(0,1,1)(0,0,0)[0] intercept   : AIC=53456.806, Time=1.22 sec
 ARIMA(0,1,0)(0,0,0)[0]             : AIC=53656.438, Time=0.09 sec
 ARIMA(1,1,2)(0,0,0)[0] intercept   : AIC=51477.106, Time=9.11 sec
 ARIMA(2,1,1)(0,0,0)[0] intercept   : AIC=50957.703, Time=4.48 sec
 ARIMA(3,1,2)(0,0,0)[0] intercept   : AIC=inf, Time=15.35 sec
 ARIMA(2,1,3)(0,0,0)[0] intercept   : AIC=inf, Time=14.48 sec
 ARIMA(1,1,1)(0,0,0)[0] intercept   : AIC=53251.497, Time=3.30 sec
 ARIMA(1,1,3)(0,0,0)[0] intercept   : AIC=51487.928, Time=5.84 sec
 ARIMA(3,1,1)(0,0,0)[0] intercept   : AIC=50867.251, Time=10.44 sec
 ARIMA(3,1,3)(0,0,0)[0] intercept   : AIC=inf, Time=16.24 sec
 ARIMA(2,1,2)(0,0,0)[0]             : AIC=50417.086, Time=2.52 sec
 ARIMA(1,1,2)(0,0,0)[0]             : AIC=51480.764, Time=1.86 sec
 ARIMA(2,1,1)(0,0,0)[0]             : AIC=50961.473, Time=1.43 sec
 ARIMA(3,1,2)(0,0,0)[0]             : AIC=inf, Time=9.94 sec
 ARIMA(2,1,3)(0,0,0)[0]             : AIC=inf, Time=5.22 sec
 ARIMA(1,1,1)(0,0,0)[0]             : AIC=53249.497, Time=0.90 sec
 ARIMA(1,1,3)(0,0,0)[0]             : AIC=51455.468, Time=2.84 sec
 ARIMA(3,1,1)(0,0,0)[0]             : AIC=50870.643, Time=4.31 sec
 ARIMA(3,1,3)(0,0,0)[0]             : AIC=inf, Time=7.38 sec

Best model:  ARIMA(2,1,2)(0,0,0)[0]          
Total fit time: 125.623 seconds
Best model: (2, 1, 2)

/usr/local/lib/python3.10/dist-packages/statsmodels/tsa/statespace/sarimax.py:966: UserWarning: Non-stationary starting autoregressive parameters found. Using zeros as starting parameters.
  warn('Non-stationary starting autoregressive parameters'
/usr/local/lib/python3.10/dist-packages/statsmodels/tsa/statespace/sarimax.py:978: UserWarning: Non-invertible starting MA parameters found. Using zeros as starting parameters.
  warn('Non-invertible starting MA parameters found.'

                               SARIMAX Results                                
==============================================================================
Dep. Variable:                      y   No. Observations:                 4030
Model:                 ARIMA(2, 1, 2)   Log Likelihood              -25203.543
Date:                Thu, 07 Nov 2024   AIC                          50417.086
Time:                        22:52:02   BIC                          50448.592
Sample:                    08-19-2013   HQIC                         50428.250
                         - 08-30-2024                                         
Covariance Type:                  opg                                         
==============================================================================
                 coef    std err          z      P>|z|      [0.025      0.975]
------------------------------------------------------------------------------
ar.L1          1.0395      0.012     88.376      0.000       1.016       1.063
ar.L2         -0.7359      0.012    -62.933      0.000      -0.759      -0.713
ma.L1         -1.5455      0.016    -93.977      0.000      -1.578      -1.513
ma.L2          0.5894      0.016     36.272      0.000       0.558       0.621
sigma2      1.587e+04    304.331     52.151      0.000    1.53e+04    1.65e+04
===================================================================================
Ljung-Box (L1) (Q):                   1.76   Jarque-Bera (JB):               291.66
Prob(Q):                              0.18   Prob(JB):                         0.00
Heteroskedasticity (H):              27.34   Skew:                            -0.34
Prob(H) (two-sided):                  0.00   Kurtosis:                         4.13
===================================================================================

Warnings:
[1] Covariance matrix calculated using the outer product of gradients (complex-step).

# Splitting the 'FUNCTIONAL_LOC' column into separate node columns
data_swire_copy[['Plant', 'Process', 'Sub_Process', 'Product_Line', 'Machine', 'Sub_Machine']] = data_swire_copy['FUNCTIONAL_LOC'].str.split('-', expand=True)

# Display the first few rows to check the split
print(data_swire_copy[['FUNCTIONAL_LOC', 'Plant', 'Process', 'Sub_Process', 'Product_Line', 'Machine', 'Sub_Machine']].head())

# Creating flag columns to indicate the presence of each node
# If a column has a value, it is flagged as 1 (present), otherwise 0 (absent)
data_swire_copy['Plant_Flag'] = data_swire_copy['Plant'].notnull().astype(int)
data_swire_copy['Process_Flag'] = data_swire_copy['Process'].notnull().astype(int)
data_swire_copy['Sub_Process_Flag'] = data_swire_copy['Sub_Process'].notnull().astype(int)
data_swire_copy['Product_Line_Flag'] = data_swire_copy['Product_Line'].notnull().astype(int)
data_swire_copy['Machine_Flag'] = data_swire_copy['Machine'].notnull().astype(int)
data_swire_copy['Sub_Machine_Flag'] = data_swire_copy['Sub_Machine'].notnull().astype(int)

# Display the updated DataFrame structure
print("\nUpdated DataFrame with flags:")
print(data_swire_copy[['Plant', 'Plant_Flag', 'Process', 'Process_Flag', 'Sub_Process', 'Sub_Process_Flag']].head())

              FUNCTIONAL_LOC Plant Process Sub_Process Product_Line Machine  \
0  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
1  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
2  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
3  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
4               G291-PRD-P05  G291     PRD         P05         None    None   

  Sub_Machine  
0         020  
1         020  
2         020  
3         020  
4        None  

Updated DataFrame with flags:
  Plant  Plant_Flag Process  Process_Flag Sub_Process  Sub_Process_Flag
0  G812           1     PRD             1         L15                 1
1  G812           1     PRD             1         L15                 1
2  G812           1     PRD             1         L15                 1
3  G812           1     PRD             1         L15                 1
4  G291           1     PRD             1         P05                 1

# Checking unique values in 'MAINTENANCE_ACTIVITY_TYPE' to understand the categories
print("Unique values in 'MAINTENANCE_ACTIVITY_TYPE':")
print(data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].unique())

# Assuming that 'Planned' and 'Unplanned' are identifiable in the 'MAINTENANCE_ACTIVITY_TYPE' column
# Replace 'Planned' and 'Unplanned' with the actual values from the dataset that represent these activities

# Filtering planned maintenance data
planned_data = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Planned', case=False, na=False)]

# Filtering unplanned maintenance data
unplanned_data = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Unplanned', case=False, na=False)]

# Display the counts for verification
print(f"Number of unplanned maintenance records: {len(unplanned_data)}")

# Display first few rows of unplanned dataset for confirmation
print("\nFirst few rows of unplanned data:")
print(unplanned_data.head())

Unique values in 'MAINTENANCE_ACTIVITY_TYPE':
['Unplanned' 'Planned']
Number of unplanned maintenance records: 1276877

First few rows of unplanned data:
    ORDER_ID PLANT_ID PRODUCTION_LOCATION EXECUTION_START_DATE  \
0  705642457     G812                ROMA           2024-05-04   
1  704191697     G812                ROMA           2022-09-13   
2  704466547     G812                ROMA           2022-12-21   
3  703834477     G812                ROMA           2022-07-04   
4  704661125     G291               MONZA           2023-03-15   

  EXECUTION_FINISH_DATE ACTUAL_START_TIME ACTUAL_FINISH_TIME  \
0            2024-05-12      06:00:00.000       23:04:08.000   
1            2022-09-13      06:00:00.000       17:17:24.000   
2            2022-12-21      07:00:00.000       07:00:00.000   
3            2022-07-04      06:00:00.000       06:00:00.000   
4            2023-03-15      07:00:00.000       07:00:00.000   

   ACTUAL_WORK_IN_MINUTES MAINTENANCE_PLAN  MAINTENANCE_ITEM  ...  \
0                   390.0              NaN               NaN  ...   
1                   420.0              NaN               NaN  ...   
2                    30.0              NaN               NaN  ...   
3                    60.0              NaN               NaN  ...   
4                   120.0              NaN               NaN  ...   

  FUNCTIONAL_AREA_NODE_2_MODIFIED    FUNCTIONAL_AREA_NODE_3_MODIFIED  \
0      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
1      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
2      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
3      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
4                     AIR SYSTEMS                                NaN   

  FUNCTIONAL_AREA_NODE_4_MODIFIED FUNCTIONAL_AREA_NODE_5_MODIFIED  \
0                        CONVEYOR               FULL CAN CONVEYOR   
1                        CONVEYOR               FULL CAN CONVEYOR   
2                        CONVEYOR               FULL CAN CONVEYOR   
3                        CONVEYOR               FULL CAN CONVEYOR   
4                             NaN                             NaN   

  EQUIPMENT_ID             EQUIPMENT_DESC EQUIP_CAT_DESC EQUIP_START_UP_DATE  \
0  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
1  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
2  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
3  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
4  300001088.0          TANK_STL_STOR_AIR       Machines          2017-02-15   

  EQUIP_VALID_FROM  EQUIP_VALID_TO  
0       2020-02-10      9999-12-31  
1       2020-02-10      9999-12-31  
2       2020-02-10      9999-12-31  
3       2020-02-10      9999-12-31  
4       2023-12-11      9999-12-31  

[5 rows x 25 columns]

# Filter for unplanned maintenance data
df_unplanned = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Unplanned', case=False, na=False)]

# Filter rows where parts have been replaced based on the 'ORDER_DESCRIPTION' column
replace_rows = df_unplanned[df_unplanned['ORDER_DESCRIPTION'].str.contains('replace', case=False, na=False)]

# Convert the 'EXECUTION_START_DATE' column to datetime format
replace_rows['EXECUTION_START_DATE'] = pd.to_datetime(replace_rows['EXECUTION_START_DATE'], errors='coerce')

# Group by 'MAINTENANCE_TYPE_DESCRIPTION' to understand counts of replacements
grouped_replace = replace_rows.groupby('MAINTENANCE_TYPE_DESCRIPTION').size()
print("Counts of parts replaced by maintenance type:\n", grouped_replace)

# Calculate the new duration using the fixed future date
fixed_future_date = replace_rows['EXECUTION_START_DATE'].max()
replace_rows['duration_new'] = (fixed_future_date - replace_rows['EXECUTION_START_DATE']).dt.days

# Create an 'event_new' column indicating unplanned maintenance occurrence (1 for event)
replace_rows['event_new'] = 1  # Since replace_rows only has rows with unplanned events

# Initialize the Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# Dictionary to store median survival times for each maintenance type
median_survival_times = {}

# List of key maintenance types for analysis
maintenance_types = [
    'Corrective Maintenance Order',
    'Administrative Order',
    'Preventive Maintenance Order'
]

# Plot Kaplan-Meier survival curves for each type of unplanned maintenance
plt.figure(figsize=(12, 8))

# Loop over each maintenance type and fit the Kaplan-Meier model
for maintenance_type in maintenance_types:
    if maintenance_type in replace_rows['MAINTENANCE_TYPE_DESCRIPTION'].unique():
        # Filter data for the current maintenance type
        type_df = replace_rows[replace_rows['MAINTENANCE_TYPE_DESCRIPTION'] == maintenance_type]

        # Fit the Kaplan-Meier model with duration and event data
        kmf.fit(durations=type_df['duration_new'], event_observed=type_df['event_new'], label=maintenance_type)

        # Store and print the median survival time for each type
        median_survival_times[maintenance_type] = kmf.median_survival_time_
        print(f"Median Survival Time for {maintenance_type}: {kmf.median_survival_time_} days")

        # Plot the survival function for this maintenance type
        kmf.plot_survival_function(ci_show=False)

# Label the plot for better visualization
plt.title("Kaplan-Meier Survival Curves for Different Maintenance Types (New Duration)")
plt.xlabel("Days Since Part Replacement")
plt.ylabel("Survival Probability")
plt.legend()
plt.grid(True)
plt.show()

# Output the calculated median survival times
print("\nMedian Survival Times (in days):")
for maintenance_type, median_time in median_survival_times.items():
    print(f"{maintenance_type}: {median_time} days")

<ipython-input-53-513457c13a07>:12: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  replace_rows['EXECUTION_START_DATE'] = pd.to_datetime(replace_rows['EXECUTION_START_DATE'], errors='coerce')
<ipython-input-53-513457c13a07>:24: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  replace_rows['duration_new'] = (fixed_future_date - replace_rows['EXECUTION_START_DATE']).dt.days
<ipython-input-53-513457c13a07>:27: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  replace_rows['event_new'] = 1  # Since replace_rows only has rows with unplanned events

Counts of parts replaced by maintenance type:
 MAINTENANCE_TYPE_DESCRIPTION
Administrative Order              266
Corrective Maintenance Order    23060
Preventive Maintenance Order       67
dtype: int64
Median Survival Time for Corrective Maintenance Order: 1231.0 days
Median Survival Time for Administrative Order: 364.0 days
Median Survival Time for Preventive Maintenance Order: 1288.0 days

Median Survival Times (in days):
Corrective Maintenance Order: 1231.0 days
Administrative Order: 364.0 days
Preventive Maintenance Order: 1288.0 days

# Filter for unplanned maintenance data
df_unplanned = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Unplanned', case=False, na=False)]

# Filter rows where parts have been replaced based on the 'ORDER_DESCRIPTION' column
replace_rows = df_unplanned[df_unplanned['ORDER_DESCRIPTION'].str.contains('replace', case=False, na=False)]

# Convert 'EXECUTION_START_DATE' to datetime format
replace_rows['EXECUTION_START_DATE'] = pd.to_datetime(replace_rows['EXECUTION_START_DATE'], errors='coerce')

# Drop rows with NaT in 'EXECUTION_START_DATE'
replace_rows = replace_rows.dropna(subset=['EXECUTION_START_DATE'])

# Calculate the new duration using the fixed future date
fixed_future_date = replace_rows['EXECUTION_START_DATE'].max()
replace_rows['duration_new'] = (fixed_future_date - replace_rows['EXECUTION_START_DATE']).dt.days

# Create an 'event_new' column indicating unplanned maintenance occurrence (1 for event)
replace_rows['event_new'] = 1  # All rows in 'replace_rows' are events

# Encode categorical variables as dummies for Cox model
cox_data = replace_rows[['duration_new', 'event_new', 'MAINTENANCE_TYPE_DESCRIPTION']]
cox_data = pd.get_dummies(cox_data, drop_first=True)

# Fit the Cox Proportional Hazards model
cph = CoxPHFitter()
cph.fit(cox_data, duration_col='duration_new', event_col='event_new')

# Print the summary of the Cox model
cph.print_summary()

# Print columns in Cox model data to identify dummy variable names
print("\nColumns in Cox model data:", cox_data.columns)

# Extract the dummy variable names for plotting
dummy_names = cox_data.columns[cox_data.columns.str.startswith('MAINTENANCE_TYPE_DESCRIPTION')]

# Plot the partial effects for the dummy variables
plt.figure(figsize=(12, 8))
for dummy_name in dummy_names:
    cph.plot_partial_effects_on_outcome(dummy_name, values=[0, 1], plot_baseline=False)

plt.title("Cox Proportional Hazards Model - Effect of Maintenance Types")
plt.xlabel("Days")
plt.ylabel("Survival Probability")
plt.grid(True)
plt.show()

# Output the summary of median survival times
print("\nMedian survival times and impacts have been evaluated based on Cox PH analysis.")


# Calculate the median survival times for different maintenance types
median_survival_times_cox = {}

for dummy_name in dummy_names:
    # Create a DataFrame to predict median survival with a specific covariate set to 1
    profile_df = pd.DataFrame(0, index=[0], columns=cox_data.columns)
    profile_df[dummy_name] = 1  # Set the specific maintenance type dummy to 1

    # Predict median survival time for the given profile
    median_time = cph.predict_median(profile_df)
    median_survival_times_cox[dummy_name] = median_time
    print(f"Median Survival Time for {dummy_name}: {median_time} days")

# Output the calculated median survival times
print("\nMedian Survival Times (in days) from Cox Model:")
for maintenance_type, median_time in median_survival_times_cox.items():
    print(f"{maintenance_type}: {median_time:.2f} days")

<ipython-input-54-5854a0746f36>:12: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  replace_rows['EXECUTION_START_DATE'] = pd.to_datetime(replace_rows['EXECUTION_START_DATE'], errors='coerce')

Columns in Cox model data: Index(['duration_new', 'event_new',
       'MAINTENANCE_TYPE_DESCRIPTION_Corrective Maintenance Order',
       'MAINTENANCE_TYPE_DESCRIPTION_Preventive Maintenance Order'],
      dtype='object')

<Figure size 1200x800 with 0 Axes>

Median survival times and impacts have been evaluated based on Cox PH analysis.
Median Survival Time for MAINTENANCE_TYPE_DESCRIPTION_Corrective Maintenance Order: 1232.0 days
Median Survival Time for MAINTENANCE_TYPE_DESCRIPTION_Preventive Maintenance Order: 1352.0 days

Median Survival Times (in days) from Cox Model:
MAINTENANCE_TYPE_DESCRIPTION_Corrective Maintenance Order: 1232.00 days
MAINTENANCE_TYPE_DESCRIPTION_Preventive Maintenance Order: 1352.00 days

# Fixed future date for censoring purposes
fixed_future_date = pd.to_datetime("2024-08-30")

# Calculate the duration to the fixed future date
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])  # Drop rows with NaT in EXECUTION_START_DATE
data_swire_copy['duration_new'] = (fixed_future_date - data_swire_copy['EXECUTION_START_DATE']).dt.days
data_swire_copy['event_new'] = 1  # Assuming all rows represent events

# Dictionary to store median survival times for each level
median_survival_times_by_level = {}

# List of hierarchical columns for analysis
hierarchical_levels = ['Plant', 'Process', 'Sub_Process', 'Product_Line', 'Machine', 'Sub_Machine']

# Loop through each level to calculate Kaplan-Meier curves and store median survival times
for level in hierarchical_levels:
    kmf = KaplanMeierFitter()
    median_survival_times_by_level[level] = {}

    for group in data_swire_copy[level].dropna().unique():  # Drop NaN and iterate over unique groups
        group_df = data_swire_copy[data_swire_copy[level] == group]

        # Fit Kaplan-Meier model for each group
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=str(group))

        # Store median survival time for each group in the current level
        median_survival_times_by_level[level][group] = kmf.median_survival_time_

# Display top 10 and lowest 10 median survival times for each level
for level in hierarchical_levels:
    print(f"\nTop 10 Median Survival Times for {level} (in days):")
    top_10 = sorted(median_survival_times_by_level[level].items(), key=lambda x: x[1], reverse=True)[:10]
    for group, median_time in top_10:
        print(f"{level} - {group}: {median_time} days")

    print(f"\nLowest 10 Median Survival Times for {level} (in days):")
    low_10 = sorted(median_survival_times_by_level[level].items(), key=lambda x: x[1])[:10]
    for group, median_time in low_10:
        print(f"{level} - {group}: {median_time} days")

    # Plot the survival curves for the top 10 and lowest 10 groups
    plt.figure(figsize=(14, 8))
    kmf = KaplanMeierFitter()

    # Plot the top 10 groups
    for group, _ in top_10:
        group_df = data_swire_copy[data_swire_copy[level] == group]
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=f"{level} - {group}")
        kmf.plot_survival_function(ci_show=False)

    plt.title(f"Kaplan-Meier Survival Curves for Top 10 {level} Groups by Median Survival Time")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title='Groups')
    plt.grid(True)
    plt.show()

    plt.figure(figsize=(14, 8))

    # Plot the lowest 10 groups
    for group, _ in low_10:
        group_df = data_swire_copy[data_swire_copy[level] == group]
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=f"{level} - {group}")
        kmf.plot_survival_function(ci_show=False)

    plt.title(f"Kaplan-Meier Survival Curves for Lowest 10 {level} Groups by Median Survival Time")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title='Groups')
    plt.grid(True)
    plt.show()

Top 10 Median Survival Times for Plant (in days):
Plant - G221: 1505.0 days
Plant - G291: 1387.0 days
Plant - G261: 1244.0 days
Plant - G816: 1143.0 days
Plant - G811: 821.0 days
Plant - G812: 772.0 days
Plant - G999: 123.0 days

Lowest 10 Median Survival Times for Plant (in days):
Plant - G999: 123.0 days
Plant - G812: 772.0 days
Plant - G811: 821.0 days
Plant - G816: 1143.0 days
Plant - G261: 1244.0 days
Plant - G291: 1387.0 days
Plant - G221: 1505.0 days

Top 10 Median Survival Times for Process (in days):
Process - CLR: 1418.0 days
Process - FLT: 1376.0 days
Process - PRD: 1198.0 days
Process - SLC: 123.0 days

Lowest 10 Median Survival Times for Process (in days):
Process - SLC: 123.0 days
Process - PRD: 1198.0 days
Process - FLT: 1376.0 days
Process - CLR: 1418.0 days

Top 10 Median Survival Times for Sub_Process (in days):
Sub_Process - P30: 2176.0 days
Sub_Process - L35: 1590.0 days
Sub_Process - A50: 1575.0 days
Sub_Process - P05: 1483.0 days
Sub_Process - A85: 1418.0 days
Sub_Process - F10: 1376.0 days
Sub_Process - P90: 1362.0 days
Sub_Process - A99: 1362.0 days
Sub_Process - P55: 1354.0 days
Sub_Process - L30: 1304.0 days

Lowest 10 Median Survival Times for Sub_Process (in days):
Sub_Process - P76: 143.0 days
Sub_Process - P95: 204.0 days
Sub_Process - B30: 230.0 days
Sub_Process - A40: 257.0 days
Sub_Process - A05: 267.0 days
Sub_Process - P50: 294.0 days
Sub_Process - A55: 339.0 days
Sub_Process - P91: 342.0 days
Sub_Process - P77: 373.0 days
Sub_Process - A28: 427.0 days

Top 10 Median Survival Times for Product_Line (in days):
Product_Line - L08: 1637.0 days
Product_Line - 006: 1585.0 days
Product_Line - I06: 1575.0 days
Product_Line - E06: 1412.0 days
Product_Line - 002: 1376.0 days
Product_Line - L04: 1329.0 days
Product_Line - L01: 1300.0 days
Product_Line - L02: 1293.0 days
Product_Line - S02: 1277.0 days
Product_Line - L09: 1256.0 days

Lowest 10 Median Survival Times for Product_Line (in days):
Product_Line - L10: 21.0 days
Product_Line - S04: 42.0 days
Product_Line - W15: 61.0 days
Product_Line - H00: 120.0 days
Product_Line - E01: 121.0 days
Product_Line - I08: 123.0 days
Product_Line - 020: 123.0 days
Product_Line - W01: 130.0 days
Product_Line - E03: 141.0 days
Product_Line - W09: 165.0 days

Top 10 Median Survival Times for Machine (in days):
Machine - S250: 2176.0 days
Machine - S280: 1727.0 days
Machine - S090: 1695.0 days
Machine - L160: 1681.0 days
Machine - 0007: 1638.0 days
Machine - L010: 1616.0 days
Machine - L170: 1592.0 days
Machine - L070: 1576.0 days
Machine - S080: 1552.0 days
Machine - L100: 1525.0 days

Lowest 10 Median Survival Times for Machine (in days):
Machine - S005: 4.0 days
Machine - C030: 5.0 days
Machine - C040: 43.0 days
Machine - S002: 45.0 days
Machine - L230: 59.0 days
Machine - S004: 75.0 days
Machine - S000: 89.0 days
Machine - S030: 97.0 days
Machine - L220: 108.0 days
Machine - S001: 117.0 days

Top 10 Median Survival Times for Sub_Machine (in days):
Sub_Machine - WEST: 1630.0 days
Sub_Machine - L010: 1234.0 days
Sub_Machine - 0020: 1196.0 days
Sub_Machine - 0040: 1169.0 days
Sub_Machine - 0035: 1123.0 days
Sub_Machine - 0030: 1001.0 days
Sub_Machine - 0050: 924.0 days
Sub_Machine - 0010: 857.0 days
Sub_Machine - 0060: 830.0 days
Sub_Machine - L040: 745.0 days

Lowest 10 Median Survival Times for Sub_Machine (in days):
Sub_Machine - 050: 34.0 days
Sub_Machine - INS: 129.0 days
Sub_Machine - ACMI: 169.0 days
Sub_Machine - 0025: 170.0 days
Sub_Machine - 0200: 174.0 days
Sub_Machine - MEAD: 178.0 days
Sub_Machine - OUT: 304.0 days
Sub_Machine - 010: 360.0 days
Sub_Machine - 0022: 371.0 days
Sub_Machine - 040: 402.0 days

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])  # Drop rows with NaT in EXECUTION_START_DATE

# Dictionary to store median survival times for each level
median_survival_times_by_level = {}

# List of hierarchical columns for analysis
hierarchical_levels = ['Plant', 'Process', 'Sub_Process', 'Product_Line', 'Machine', 'Sub_Machine']

# Loop through each level to calculate Kaplan-Meier curves and store median survival times
for level in hierarchical_levels:
    kmf = KaplanMeierFitter()
    median_survival_times_by_level[level] = {}

    # Find the latest maintenance date for each group within the level
    last_dates = data_swire_copy.groupby(level)['EXECUTION_START_DATE'].max()

    # Calculate duration for each row by subtracting EXECUTION_START_DATE from the latest date for each group
    data_swire_copy['duration_new'] = data_swire_copy.apply(
        lambda row: (last_dates[row[level]] - row['EXECUTION_START_DATE']).days
        if row[level] in last_dates else np.nan,
        axis=1
    )

    # Create an 'event_new' column indicating unplanned maintenance occurrence (1 for event)
    data_swire_copy['event_new'] = 1  # Assuming all rows represent events

    # Loop over each group in the current hierarchical level to fit the Kaplan-Meier model
    for group in data_swire_copy[level].dropna().unique():  # Drop NaN and iterate over unique groups
        group_df = data_swire_copy[data_swire_copy[level] == group]

        # Fit Kaplan-Meier model for each group
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=str(group))

        # Store median survival time for each group in the current level
        median_survival_times_by_level[level][group] = kmf.median_survival_time_

    # Display top 10 and lowest 10 median survival times for each level
    print(f"\nTop 10 Median Survival Times for {level} (in days):")
    top_10 = sorted(median_survival_times_by_level[level].items(), key=lambda x: x[1], reverse=True)[:10]
    for group, median_time in top_10:
        print(f"{level} - {group}: {median_time} days")

    print(f"\nLowest 10 Median Survival Times for {level} (in days):")
    low_10 = sorted(median_survival_times_by_level[level].items(), key=lambda x: x[1])[:10]
    for group, median_time in low_10:
        print(f"{level} - {group}: {median_time} days")

    # Plot the survival curves for the top 10 and lowest 10 groups
    plt.figure(figsize=(14, 8))
    kmf = KaplanMeierFitter()

    # Plot the top 10 groups
    for group, _ in top_10:
        group_df = data_swire_copy[data_swire_copy[level] == group]
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=f"{level} - {group}")
        kmf.plot_survival_function(ci_show=False)

    plt.title(f"Kaplan-Meier Survival Curves for Top 10 {level} Groups by Median Survival Time")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title='Groups')
    plt.grid(True)
    plt.show()

    plt.figure(figsize=(14, 8))

    # Plot the lowest 10 groups
    for group, _ in low_10:
        group_df = data_swire_copy[data_swire_copy[level] == group]
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=f"{level} - {group}")
        kmf.plot_survival_function(ci_show=False)

    plt.title(f"Kaplan-Meier Survival Curves for Lowest 10 {level} Groups by Median Survival Time")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title='Groups')
    plt.grid(True)
    plt.show()

Top 10 Median Survival Times for Plant (in days):
Plant - G221: 1504.0 days
Plant - G291: 1386.0 days
Plant - G261: 1243.0 days
Plant - G816: 1142.0 days
Plant - G811: 820.0 days
Plant - G812: 771.0 days
Plant - G999: 121.0 days

Lowest 10 Median Survival Times for Plant (in days):
Plant - G999: 121.0 days
Plant - G812: 771.0 days
Plant - G811: 820.0 days
Plant - G816: 1142.0 days
Plant - G261: 1243.0 days
Plant - G291: 1386.0 days
Plant - G221: 1504.0 days

Top 10 Median Survival Times for Process (in days):
Process - CLR: 1417.0 days
Process - PRD: 1197.0 days
Process - FLT: 907.0 days
Process - SLC: 121.0 days

Lowest 10 Median Survival Times for Process (in days):
Process - SLC: 121.0 days
Process - FLT: 907.0 days
Process - PRD: 1197.0 days
Process - CLR: 1417.0 days

Top 10 Median Survival Times for Sub_Process (in days):
Sub_Process - P30: 2141.0 days
Sub_Process - A50: 1573.0 days
Sub_Process - P05: 1481.0 days
Sub_Process - A85: 1417.0 days
Sub_Process - P90: 1360.0 days
Sub_Process - L35: 1349.0 days
Sub_Process - P55: 1336.0 days
Sub_Process - A99: 1336.0 days
Sub_Process - L30: 1303.0 days
Sub_Process - P85: 1284.0 days

Lowest 10 Median Survival Times for Sub_Process (in days):
Sub_Process - P60: 0.0 days
Sub_Process - P95: 0.0 days
Sub_Process - PRD: 0.0 days
Sub_Process - P76: 136.0 days
Sub_Process - B30: 229.0 days
Sub_Process - A40: 255.0 days
Sub_Process - A05: 264.0 days
Sub_Process - P50: 287.0 days
Sub_Process - A55: 338.0 days
Sub_Process - P91: 341.0 days

Top 10 Median Survival Times for Product_Line (in days):
Product_Line - I06: 1554.0 days
Product_Line - E06: 1411.0 days
Product_Line - L08: 1396.0 days
Product_Line - L04: 1328.0 days
Product_Line - L01: 1299.0 days
Product_Line - L02: 1292.0 days
Product_Line - L09: 1255.0 days
Product_Line - S02: 1247.0 days
Product_Line - R03: 1232.0 days
Product_Line - XXX: 1206.0 days

Lowest 10 Median Survival Times for Product_Line (in days):
Product_Line - S04: 0.0 days
Product_Line - 006: 0.0 days
Product_Line - E05: 0.0 days
Product_Line - E01: 2.0 days
Product_Line - L10: 20.0 days
Product_Line - W15: 57.0 days
Product_Line - W11: 64.0 days
Product_Line - W01: 66.0 days
Product_Line - H00: 117.0 days
Product_Line - I08: 119.0 days

Top 10 Median Survival Times for Machine (in days):
Machine - S250: 2141.0 days
Machine - L160: 1680.0 days
Machine - S090: 1669.0 days
Machine - L010: 1615.0 days
Machine - L170: 1591.0 days
Machine - L070: 1574.0 days
Machine - S080: 1549.0 days
Machine - L100: 1524.0 days
Machine - 0003: 1446.0 days
Machine - S280: 1426.0 days

Lowest 10 Median Survival Times for Machine (in days):
Machine - S002: 0.0 days
Machine - S005: 0.0 days
Machine - S050: 0.0 days
Machine - C040: 0.0 days
Machine - C030: 0.0 days
Machine - L230: 0.0 days
Machine - L00: 14.0 days
Machine - S030: 19.0 days
Machine - S010: 64.0 days
Machine - S004: 68.0 days

Top 10 Median Survival Times for Sub_Machine (in days):
Sub_Machine - 0020: 1191.0 days
Sub_Machine - WEST: 1005.0 days
Sub_Machine - 0035: 997.0 days
Sub_Machine - 0030: 969.0 days
Sub_Machine - 0050: 915.0 days
Sub_Machine - 0010: 846.0 days
Sub_Machine - L010: 744.0 days
Sub_Machine - L040: 731.0 days
Sub_Machine - L030: 705.0 days
Sub_Machine - 0040: 692.0 days

Lowest 10 Median Survival Times for Sub_Machine (in days):
Sub_Machine - B010: 0.0 days
Sub_Machine - B111: 0.0 days
Sub_Machine - 050: 0.0 days
Sub_Machine - B112: 8.0 days
Sub_Machine - 0200: 95.0 days
Sub_Machine - OUT: 104.0 days
Sub_Machine - INS: 120.0 days
Sub_Machine - ACMI: 161.0 days
Sub_Machine - 0025: 162.0 days
Sub_Machine - 030: 175.0 days

# Convert dates to datetime format
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'], errors='coerce')
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_FINISH_DATE', 'EXECUTION_START_DATE'])

# Calculate duration from EXECUTION_FINISH_DATE to the next unplanned maintenance
data_swire_copy['duration_new'] = (data_swire_copy['EXECUTION_FINISH_DATE'].max() - data_swire_copy['EXECUTION_FINISH_DATE']).dt.days
data_swire_copy['event_new'] = 1  # Assuming all rows represent events

# Initialize Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# Impact of Part Replacement on Time to Next Maintenance
print("\nHypothesis 2: Impact of Part Replacement on Time to Next Maintenance")
plt.figure(figsize=(10, 6))
for replacement in [True, False]:  # True if 'replace' is in ORDER_DESCRIPTION
    subset = data_swire_copy[data_swire_copy['ORDER_DESCRIPTION'].str.contains('replace', case=False) == replacement]
    label = "Replacement" if replacement else "No Replacement"

    # Fit Kaplan-Meier model for each group
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=label)
    kmf.plot_survival_function(ci_show=False)

    # Print median survival time
    median_survival = kmf.median_survival_time_
    print(f"{label} - Median Survival Time: {median_survival} days")

    # Print survival probability at specific time points
    for days in [30, 90, 180, 365]:
        survival_prob = kmf.survival_function_at_times(days).values[0]
        print(f"{label} - Survival Probability at {days} days: {survival_prob:.4f}")

plt.title("Kaplan-Meier Survival Curves for Part Replacement vs. No Replacement")
plt.xlabel("Days Since Maintenance Completion")
plt.ylabel("Survival Probability")
plt.legend(title='Replacement Status')
plt.grid(True)
plt.show()

# Hypothesis 4: Differences by Hierarchical Level (Plant Level)
print("\nHypothesis 4: Differences in Survival by Plant Level")
plt.figure(figsize=(10, 6))
for plant in data_swire_copy['Plant'].dropna().unique():
    subset = data_swire_copy[data_swire_copy['Plant'] == plant]
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=f"Plant {plant}")
    kmf.plot_survival_function(ci_show=False)

    # Print median survival time for each plant
    median_survival = kmf.median_survival_time_
    print(f"Plant {plant} - Median Survival Time: {median_survival} days")

    # Print survival probabilities at specific time points
    for days in [30, 90, 180, 365]:
        survival_prob = kmf.survival_function_at_times(days).values[0]
        print(f"Plant {plant} - Survival Probability at {days} days: {survival_prob:.4f}")

plt.title("Kaplan-Meier Survival Curves by Plant Level")
plt.xlabel("Days Since Maintenance Completion")
plt.ylabel("Survival Probability")
plt.legend(title='Plant Level')
plt.grid(True)
plt.show()

# Influence of Maintenance Season on Future Failures
print("\nHypothesis 5: Influence of Maintenance Season on Time to Failure")
# Define seasons based on finish date
data_swire_copy['season'] = data_swire_copy['EXECUTION_FINISH_DATE'].dt.month % 12 // 3 + 1  # 1=Winter, 2=Spring, 3=Summer, 4=Fall
season_labels = {1: "Winter", 2: "Spring", 3: "Summer", 4: "Fall"}
plt.figure(figsize=(10, 6))
for season in data_swire_copy['season'].unique():
    subset = data_swire_copy[data_swire_copy['season'] == season]
    label = season_labels[season]

    # Fit Kaplan-Meier model for each season
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=label)
    kmf.plot_survival_function(ci_show=False)

    # Print median survival time for each season
    median_survival = kmf.median_survival_time_
    print(f"{label} Season - Median Survival Time: {median_survival} days")

    # Print survival probabilities at specific time points
    for days in [30, 90, 180, 365]:
        survival_prob = kmf.survival_function_at_times(days).values[0]
        print(f"{label} Season - Survival Probability at {days} days: {survival_prob:.4f}")

plt.title("Kaplan-Meier Survival Curves by Maintenance Season")
plt.xlabel("Days Since Maintenance Completion")
plt.ylabel("Survival Probability")
plt.legend(title='Season')
plt.grid(True)
plt.show()

Hypothesis 2: Impact of Part Replacement on Time to Next Maintenance
Replacement - Median Survival Time: 1222.0 days
Replacement - Survival Probability at 30 days: 0.9849
Replacement - Survival Probability at 90 days: 0.9584
Replacement - Survival Probability at 180 days: 0.9234
Replacement - Survival Probability at 365 days: 0.8416
No Replacement - Median Survival Time: 1197.0 days
No Replacement - Survival Probability at 30 days: 0.9843
No Replacement - Survival Probability at 90 days: 0.9542
No Replacement - Survival Probability at 180 days: 0.9121
No Replacement - Survival Probability at 365 days: 0.8262

Hypothesis 4: Differences in Survival by Plant Level
Plant G812 - Median Survival Time: 771.0 days
Plant G812 - Survival Probability at 30 days: 0.9812
Plant G812 - Survival Probability at 90 days: 0.9425
Plant G812 - Survival Probability at 180 days: 0.8853
Plant G812 - Survival Probability at 365 days: 0.7502
Plant G291 - Median Survival Time: 1387.0 days
Plant G291 - Survival Probability at 30 days: 0.9864
Plant G291 - Survival Probability at 90 days: 0.9567
Plant G291 - Survival Probability at 180 days: 0.9152
Plant G291 - Survival Probability at 365 days: 0.8421
Plant G816 - Median Survival Time: 1143.0 days
Plant G816 - Survival Probability at 30 days: 0.9810
Plant G816 - Survival Probability at 90 days: 0.9498
Plant G816 - Survival Probability at 180 days: 0.9149
Plant G816 - Survival Probability at 365 days: 0.8529
Plant G811 - Median Survival Time: 821.0 days
Plant G811 - Survival Probability at 30 days: 0.9730
Plant G811 - Survival Probability at 90 days: 0.9253
Plant G811 - Survival Probability at 180 days: 0.8577
Plant G811 - Survival Probability at 365 days: 0.7443
Plant G261 - Median Survival Time: 1242.0 days
Plant G261 - Survival Probability at 30 days: 0.9891
Plant G261 - Survival Probability at 90 days: 0.9702
Plant G261 - Survival Probability at 180 days: 0.9421
Plant G261 - Survival Probability at 365 days: 0.8667
Plant G221 - Median Survival Time: 1505.0 days
Plant G221 - Survival Probability at 30 days: 0.9892
Plant G221 - Survival Probability at 90 days: 0.9635
Plant G221 - Survival Probability at 180 days: 0.9200
Plant G221 - Survival Probability at 365 days: 0.8250
Plant G999 - Median Survival Time: 123.0 days
Plant G999 - Survival Probability at 30 days: 0.8869
Plant G999 - Survival Probability at 90 days: 0.6190
Plant G999 - Survival Probability at 180 days: 0.3214
Plant G999 - Survival Probability at 365 days: 0.0119

Hypothesis 5: Influence of Maintenance Season on Time to Failure
Spring Season - Median Survival Time: 1254.0 days
Spring Season - Survival Probability at 30 days: 1.0000
Spring Season - Survival Probability at 90 days: 1.0000
Spring Season - Survival Probability at 180 days: 0.8558
Spring Season - Survival Probability at 365 days: 0.8531
Fall Season - Median Survival Time: 1425.0 days
Fall Season - Survival Probability at 30 days: 1.0000
Fall Season - Survival Probability at 90 days: 1.0000
Fall Season - Survival Probability at 180 days: 1.0000
Fall Season - Survival Probability at 365 days: 0.8511
Winter Season - Median Survival Time: 1332.0 days
Winter Season - Survival Probability at 30 days: 1.0000
Winter Season - Survival Probability at 90 days: 1.0000
Winter Season - Survival Probability at 180 days: 1.0000
Winter Season - Survival Probability at 365 days: 0.8471
Summer Season - Median Survival Time: 1179.0 days
Summer Season - Survival Probability at 30 days: 0.9500
Summer Season - Survival Probability at 90 days: 0.8556
Summer Season - Survival Probability at 180 days: 0.8556
Summer Season - Survival Probability at 365 days: 0.8535

# Filter for unplanned maintenance data
df_unplanned = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Unplanned', case=False, na=False)]

# Filter rows where shutdowns occurred based on 'ORDER_DESCRIPTION'
shutdown_rows = df_unplanned[df_unplanned['ORDER_DESCRIPTION'].str.contains('shutdown', case=False, na=False)]

# Convert 'EXECUTION_START_DATE' to datetime format for calculating durations
shutdown_rows['EXECUTION_START_DATE'] = pd.to_datetime(shutdown_rows['EXECUTION_START_DATE'], errors='coerce')

# Calculate the duration to the latest shutdown date
fixed_future_date = shutdown_rows['EXECUTION_START_DATE'].max()
shutdown_rows['duration_new'] = (fixed_future_date - shutdown_rows['EXECUTION_START_DATE']).dt.days

# Create an 'event_new' column indicating an unplanned maintenance occurrence (1 for event)
shutdown_rows['event_new'] = 1  # Since shutdown_rows only includes unplanned events

# Initialize the Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# Dictionary to store median survival times for shutdown vs. non-shutdown events
median_survival_times = {}

# List of shutdown vs non-shutdown groups
shutdown_status = ["Shutdown", "No Shutdown"]

plt.figure(figsize=(12, 8))

# Loop over each status to fit Kaplan-Meier models
for status in shutdown_status:
    if status == "Shutdown":
        type_df = shutdown_rows
    else:
        type_df = df_unplanned[~df_unplanned['ORDER_DESCRIPTION'].str.contains('shutdown', case=False, na=False)]

    # Ensure EXECUTION_START_DATE is in datetime format
    type_df['EXECUTION_START_DATE'] = pd.to_datetime(type_df['EXECUTION_START_DATE'], errors='coerce')
    type_df = type_df.dropna(subset=['EXECUTION_START_DATE'])

    # Calculate duration based on the latest shutdown date
    type_df['duration_new'] = (fixed_future_date - type_df['EXECUTION_START_DATE']).dt.days
    type_df['event_new'] = 1  # Assuming all rows are events

    # Fit Kaplan-Meier model for each shutdown status
    kmf.fit(durations=type_df['duration_new'], event_observed=type_df['event_new'], label=status)

    # Store and print median survival time for each type
    median_survival_times[status] = kmf.median_survival_time_
    print(f"Median Survival Time for {status}: {kmf.median_survival_time_} days")

    # Plot the survival function for this group
    kmf.plot_survival_function(ci_show=False)

# Label the plot for better visualization
plt.title("Kaplan-Meier Survival Curves for Shutdown vs. Non-Shutdown Maintenance Events")
plt.xlabel("Days Since Last Maintenance")
plt.ylabel("Survival Probability")
plt.legend()
plt.grid(True)
plt.show()

# Output the calculated median survival times
print("\nMedian Survival Times (in days):")
for status, median_time in median_survival_times.items():
    print(f"{status}: {median_time} days")

<ipython-input-69-a1b1a05dc133>:14: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  shutdown_rows['EXECUTION_START_DATE'] = pd.to_datetime(shutdown_rows['EXECUTION_START_DATE'], errors='coerce')
<ipython-input-69-a1b1a05dc133>:18: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  shutdown_rows['duration_new'] = (fixed_future_date - shutdown_rows['EXECUTION_START_DATE']).dt.days
<ipython-input-69-a1b1a05dc133>:21: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  shutdown_rows['event_new'] = 1  # Since shutdown_rows only includes unplanned events
<ipython-input-69-a1b1a05dc133>:42: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  type_df['EXECUTION_START_DATE'] = pd.to_datetime(type_df['EXECUTION_START_DATE'], errors='coerce')

Median Survival Time for Shutdown: 421.0 days

<ipython-input-69-a1b1a05dc133>:42: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  type_df['EXECUTION_START_DATE'] = pd.to_datetime(type_df['EXECUTION_START_DATE'], errors='coerce')

Median Survival Time for No Shutdown: 1340.0 days

Median Survival Times (in days):
Shutdown: 421.0 days
No Shutdown: 1340.0 days

# Convert relevant date columns to datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'], errors='coerce')
data_swire_copy['EQUIP_VALID_FROM'] = pd.to_datetime(data_swire_copy['EQUIP_VALID_FROM'], errors='coerce')
data_swire_copy['EQUIP_VALID_TO'] = pd.to_datetime(data_swire_copy['EQUIP_VALID_TO'], errors='coerce')
data_swire_copy.dropna(subset=['EXECUTION_START_DATE', 'EXECUTION_FINISH_DATE'], inplace=True)

# Calculate duration from EXECUTION_FINISH_DATE to a future date or next maintenance event
data_swire_copy['duration_new'] = (data_swire_copy['EXECUTION_FINISH_DATE'].max() - data_swire_copy['EXECUTION_FINISH_DATE']).dt.days
data_swire_copy['event_new'] = 1  # Assuming all rows represent events (maintenance was completed)

# Initialize Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# Age of Equipment and Frequency of Breakdown
print("\nHypothesis 1: Age of Equipment and Frequency of Breakdown")
data_swire_copy['equipment_age'] = (data_swire_copy['EXECUTION_FINISH_DATE'] - data_swire_copy['EQUIP_VALID_FROM']).dt.days
age_categories = pd.qcut(data_swire_copy['equipment_age'], q=4)

plt.figure(figsize=(10, 6))
for age_group in age_categories.cat.categories:  # Loop over the interval categories
    subset = data_swire_copy[(data_swire_copy['equipment_age'] >= age_group.left) & (data_swire_copy['equipment_age'] <= age_group.right)]
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=f"Age {age_group}")
    kmf.plot_survival_function(ci_show=False)

plt.title("Survival Curves by Equipment Age")
plt.xlabel("Days Since Last Maintenance")
plt.ylabel("Survival Probability")
plt.legend(title='Equipment Age Group')
plt.grid(True)
plt.show()

# Impact of Planned vs. Unplanned Maintenance on Downtime
print("\nHypothesis 2: Planned vs. Unplanned Maintenance")
for maintenance_type in ['Preventive', 'Corrective']:
    subset = data_swire_copy[data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'].str.contains(maintenance_type, case=False, na=False)]
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=f"{maintenance_type} Maintenance")
    kmf.plot_survival_function(ci_show=False)

plt.title("Survival Curves by Maintenance Type")
plt.xlabel("Days Since Last Maintenance")
plt.ylabel("Survival Probability")
plt.legend(title='Maintenance Type')
plt.grid(True)
plt.show()

# Hypothesis 3: Seasonal Influence on Maintenance Needs
print("\nHypothesis 3: Influence of Season on Maintenance")
data_swire_copy['season'] = data_swire_copy['EXECUTION_FINISH_DATE'].dt.month % 12 // 3 + 1  # 1=Winter, 2=Spring, etc.
season_labels = {1: "Winter", 2: "Spring", 3: "Summer", 4: "Fall"}
plt.figure(figsize=(10, 6))
for season in data_swire_copy['season'].unique():
    subset = data_swire_copy[data_swire_copy['season'] == season]
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=season_labels[season])
    kmf.plot_survival_function(ci_show=False)

plt.title("Survival Curves by Season")
plt.xlabel("Days Since Maintenance Completion")
plt.ylabel("Survival Probability")
plt.legend(title='Season')
plt.grid(True)
plt.show()

# Type of Maintenance and Part Replacement Frequency
print("\nHypothesis 4: Type of Maintenance and Part Replacement")
for replacement in [True, False]:  # True if 'replace' is in ORDER_DESCRIPTION
    subset = data_swire_copy[data_swire_copy['ORDER_DESCRIPTION'].str.contains('replace', case=False) == replacement]
    label = "Replacement" if replacement else "No Replacement"
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=label)
    kmf.plot_survival_function(ci_show=False)

plt.title("Survival Curves for Part Replacement vs. No Replacement")
plt.xlabel("Days Since Maintenance Completion")
plt.ylabel("Survival Probability")
plt.legend(title='Replacement Status')
plt.grid(True)
plt.show()

# Hypothesis 5: Downtime and Opportunity Cost
print("\nHypothesis 5: Downtime and Opportunity Cost")
data_swire_copy['downtime_category'] = pd.qcut(data_swire_copy['ACTUAL_WORK_IN_MINUTES'], q=3, labels=["Low", "Medium", "High"])
for downtime_category in data_swire_copy['downtime_category'].unique():
    subset = data_swire_copy[data_swire_copy['downtime_category'] == downtime_category]
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=f"Downtime: {downtime_category}")
    kmf.plot_survival_function(ci_show=False)

plt.title("Survival Curves by Downtime Category")
plt.xlabel("Days Since Last Maintenance")
plt.ylabel("Survival Probability")
plt.legend(title='Downtime Category')
plt.grid(True)
plt.show()

# Functional Location and Breakdown Frequency
print("\nHypothesis 6: Functional Location and Breakdown Frequency")
plt.figure(figsize=(10, 6))
for location in data_swire_copy['FUNCTIONAL_LOC'].dropna().unique()[:5]:  # Limit to first 5 locations for clarity
    subset = data_swire_copy[data_swire_copy['FUNCTIONAL_LOC'] == location]
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=f"Location: {location}")
    kmf.plot_survival_function(ci_show=False)

plt.title("Survival Curves by Functional Location")
plt.xlabel("Days Since Last Maintenance")
plt.ylabel("Survival Probability")
plt.legend(title='Functional Location')
plt.grid(True)
plt.show()

# Part Replacement and Time to Next Failure
print("\nHypothesis 7: Part Replacement and Time to Next Failure")
for replacement in [True, False]:  # True if 'replace' is in ORDER_DESCRIPTION
    subset = data_swire_copy[data_swire_copy['ORDER_DESCRIPTION'].str.contains('replace', case=False) == replacement]
    label = "Replacement" if replacement else "No Replacement"
    kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=label)
    kmf.plot_survival_function(ci_show=False)

plt.title("Survival Curves for Part Replacement Impact on Time to Next Failure")
plt.xlabel("Days Since Maintenance Completion")
plt.ylabel("Survival Probability")
plt.legend(title='Replacement Status')
plt.grid(True)
plt.show()

Hypothesis 1: Age of Equipment and Frequency of Breakdown

Hypothesis 2: Planned vs. Unplanned Maintenance

Hypothesis 3: Influence of Season on Maintenance

Hypothesis 4: Type of Maintenance and Part Replacement

Hypothesis 5: Downtime and Opportunity Cost

Hypothesis 6: Functional Location and Breakdown Frequency

Hypothesis 7: Part Replacement and Time to Next Failure

# Functional Node Impact on Maintenance Failure Frequency and Time to Next Failure

# Convert relevant date columns to datetime format
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_FINISH_DATE'])

# Calculate duration from EXECUTION_FINISH_DATE to the end of observation period
data_swire_copy['duration_new'] = (data_swire_copy['EXECUTION_FINISH_DATE'].max() - data_swire_copy['EXECUTION_FINISH_DATE']).dt.days
data_swire_copy['event_new'] = 1  # Assuming all rows represent events (failure occurred)

# List of functional nodes to analyze
functional_nodes = [
    'FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
    'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED',
    'FUNCTIONAL_AREA_NODE_5_MODIFIED'
]

# Initialize Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# Loop through each functional node to calculate top 10 failure frequencies and plot
for node in functional_nodes:
    # Calculate failure frequency for each unique value in the current functional node
    failure_counts = data_swire_copy[node].value_counts().nlargest(10)

    print(f"\nTop 10 Failure Frequencies for {node}:")
    print(failure_counts)

    # Plot Kaplan-Meier survival curves for each of the top 10 values in the current node
    plt.figure(figsize=(10, 6))
    for value in failure_counts.index:
        subset = data_swire_copy[data_swire_copy[node] == value]

        # Fit Kaplan-Meier model for each value
        kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=f"{node}: {value}")

        # Print the median survival time for each node value
        median_survival_time = kmf.median_survival_time_
        print(f"Median Survival Time for {node} - {value}: {median_survival_time} days")

        # Plot the survival function
        kmf.plot_survival_function(ci_show=False)

    # Configure plot for better visualization
    plt.title(f"Kaplan-Meier Survival Curves for Top 10 Failure Frequencies in {node}")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title=node)
    plt.grid(True)
    plt.show()

Top 10 Failure Frequencies for FUNCTIONAL_AREA_NODE_1_MODIFIED:
FUNCTIONAL_AREA_NODE_1_MODIFIED
COTA PRODUCTION           70187
SILVERSTONE PRODUCTION    62625
PRODUCTION                60312
MONZA PRODUCTION          57458
SUZUKA PRODUCTION         36713
COOLER SERVICE             2699
FLEET                       123
Name: count, dtype: int64
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - COTA PRODUCTION: 1143.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - SILVERSTONE PRODUCTION: 1242.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - PRODUCTION: 767.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - MONZA PRODUCTION: 1386.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - SUZUKA PRODUCTION: 1515.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - COOLER SERVICE: 1418.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - FLEET: 1376.0 days

Top 10 Failure Frequencies for FUNCTIONAL_AREA_NODE_2_MODIFIED:
FUNCTIONAL_AREA_NODE_2_MODIFIED
CAN LINE                       34208
BTL_PET_LINE                   32789
LINES 1,2,9 - BOTTLE LINES     29729
BOTTLE LINE                    27543
LINES 3,4,10 - CAN LINES       23153
L1, L2, L6 PET BOTTLE LINES    22460
G812 PRD FILLER_ROTARY_CAN     17390
ROTARY_CAN_LINE                14016
G812 PRD FILLER_ROT_BTL_PET    11200
L4 - FILLER_ROTARY_CAN         10799
Name: count, dtype: int64
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - CAN LINE: 1095.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - BTL_PET_LINE: 1359.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINES 1,2,9 - BOTTLE LINES: 1289.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - BOTTLE LINE: 1186.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINES 3,4,10 - CAN LINES: 1175.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - L1, L2, L6 PET BOTTLE LINES: 1494.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - G812 PRD FILLER_ROTARY_CAN: 936.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - ROTARY_CAN_LINE: 1566.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - G812 PRD FILLER_ROT_BTL_PET: 1552.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - L4 - FILLER_ROTARY_CAN: 1576.0 days

Top 10 Failure Frequencies for FUNCTIONAL_AREA_NODE_3_MODIFIED:
FUNCTIONAL_AREA_NODE_3_MODIFIED
LINE #4-FILLER_ROTARY_CAN             35834
LINE #2 - FILLER_ROT_BTL_PET          23027
LINE #1 - FILLER_ROT_BTL_PET          18290
LINE #1-CAN_LINE                      17844
LINE #2 - BOTTLE_LINE_PET             17774
LINE #3-CAN_LINE                      16364
G812 PRD FILLER_ROTARY_CAN LINE 1     12984
LINE #3-FILLER_ROTARY_CAN             12013
G812 PRD FILLER_ROT_BTL_PET LINE 2    11200
LINE #2 - ROT_BTL_PET                 10674
Name: count, dtype: int64
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #4-FILLER_ROTARY_CAN: 1396.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - FILLER_ROT_BTL_PET: 1379.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #1 - FILLER_ROT_BTL_PET: 1587.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #1-CAN_LINE: 1061.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - BOTTLE_LINE_PET: 1191.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #3-CAN_LINE: 1137.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - G812 PRD FILLER_ROTARY_CAN LINE 1: 1554.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #3-FILLER_ROTARY_CAN: 1237.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - G812 PRD FILLER_ROT_BTL_PET LINE 2: 1552.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - ROT_BTL_PET: 1298.0 days

Top 10 Failure Frequencies for FUNCTIONAL_AREA_NODE_4_MODIFIED:
FUNCTIONAL_AREA_NODE_4_MODIFIED
FILLER               46322
PACKER               35230
CONVEYOR             34765
LABELER              18945
PALLETIZER           16239
DEPALLETIZER         10850
DETECTOR, PRODUCT     9404
SEAMER, ROTARY        8510
CAPPER                8350
WARMER_COOLER         7686
Name: count, dtype: int64
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - FILLER: 1177.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - PACKER: 1193.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - CONVEYOR: 1139.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - LABELER: 1524.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - PALLETIZER: 1242.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - DEPALLETIZER: 1114.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - DETECTOR, PRODUCT: 1576.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - SEAMER, ROTARY: 1204.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - CAPPER: 1621.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - WARMER_COOLER: 1606.0 days

Top 10 Failure Frequencies for FUNCTIONAL_AREA_NODE_5_MODIFIED:
FUNCTIONAL_AREA_NODE_5_MODIFIED
FULL CAN TO ACCUMULATION TABLE           251
PACKER 1, MODEL DUODOZEN 1250SX          210
FULL CASE CONVEYORS                      158
EMPTY CASE CONVEYORS                     136
FULL CASE SPIRAL TO PALLETIZER           125
FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT    114
EMPTY CAN                                110
COMPRESSOR                               110
PACKER 2, MODEL FENIX 185V               108
FULL CASE CONVEYOR                       101
Name: count, dtype: int64
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CAN TO ACCUMULATION TABLE: 842.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - PACKER 1, MODEL DUODOZEN 1250SX: 176.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE CONVEYORS: 745.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - EMPTY CASE CONVEYORS: 711.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE SPIRAL TO PALLETIZER: 478.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT: 1050.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - EMPTY CAN: 938.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - COMPRESSOR: 555.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - PACKER 2, MODEL FENIX 185V: 167.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE CONVEYOR: 402.0 days

# Impact of Functional Node on Maintenance Duration and Frequency of Failures

# Convert 'ACTUAL_WORK_IN_MINUTES' to hours for better interpretation
data_swire_copy['maintenance_duration_hours'] = data_swire_copy['ACTUAL_WORK_IN_MINUTES'] / 60

# Initialize Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# List of functional nodes to analyze
functional_nodes = [
    'FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
    'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED',
    'FUNCTIONAL_AREA_NODE_5_MODIFIED'
]

# Analyze maintenance duration by functional node
for node in functional_nodes:
    # Calculate top 10 most frequent values in the current node
    top_values = data_swire_copy[node].value_counts().nlargest(10)

    print(f"\nKaplan-Meier Survival Analysis of Maintenance Duration for {node}")
    plt.figure(figsize=(10, 6))

    # Loop through the top 10 values for the current functional node
    for value in top_values.index:
        subset = data_swire_copy[data_swire_copy[node] == value]

        # Fit Kaplan-Meier model with maintenance duration as 'duration'
        kmf.fit(durations=subset['maintenance_duration_hours'], event_observed=subset['event_new'], label=f"{node}: {value}")

        # Print the median survival time for each node value
        median_survival_time = kmf.median_survival_time_
        print(f"Median Survival Time for {node} - {value}: {median_survival_time} hours")

        # Plot the survival function
        kmf.plot_survival_function(ci_show=False)

    plt.title(f"Kaplan-Meier Survival Curves for Maintenance Duration by {node}")
    plt.xlabel("Hours of Maintenance Work")
    plt.ylabel("Survival Probability")
    plt.legend(title=node)
    plt.grid(True)
    plt.show()

Kaplan-Meier Survival Analysis of Maintenance Duration for FUNCTIONAL_AREA_NODE_1_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - COTA PRODUCTION: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - SILVERSTONE PRODUCTION: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - PRODUCTION: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - MONZA PRODUCTION: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - SUZUKA PRODUCTION: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - COOLER SERVICE: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - FLEET: 1.5 hours

Kaplan-Meier Survival Analysis of Maintenance Duration for FUNCTIONAL_AREA_NODE_2_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - CAN LINE: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - BTL_PET_LINE: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINES 1,2,9 - BOTTLE LINES: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - BOTTLE LINE: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINES 3,4,10 - CAN LINES: 0.9 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - L1, L2, L6 PET BOTTLE LINES: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - G812 PRD FILLER_ROTARY_CAN: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - ROTARY_CAN_LINE: 0.3 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - G812 PRD FILLER_ROT_BTL_PET: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - L4 - FILLER_ROTARY_CAN: 1.0 hours

Kaplan-Meier Survival Analysis of Maintenance Duration for FUNCTIONAL_AREA_NODE_3_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #4-FILLER_ROTARY_CAN: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - FILLER_ROT_BTL_PET: 0.7 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #1 - FILLER_ROT_BTL_PET: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #1-CAN_LINE: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - BOTTLE_LINE_PET: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #3-CAN_LINE: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - G812 PRD FILLER_ROTARY_CAN LINE 1: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #3-FILLER_ROTARY_CAN: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - G812 PRD FILLER_ROT_BTL_PET LINE 2: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - ROT_BTL_PET: 1.0 hours

Kaplan-Meier Survival Analysis of Maintenance Duration for FUNCTIONAL_AREA_NODE_4_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - FILLER: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - PACKER: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - CONVEYOR: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - LABELER: 0.75 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - PALLETIZER: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - DEPALLETIZER: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - DETECTOR, PRODUCT: 0.3 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - SEAMER, ROTARY: 0.9 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - CAPPER: 0.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - WARMER_COOLER: 0.5 hours

Kaplan-Meier Survival Analysis of Maintenance Duration for FUNCTIONAL_AREA_NODE_5_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CAN TO ACCUMULATION TABLE: 1.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - PACKER 1, MODEL DUODOZEN 1250SX: 1.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE CONVEYORS: 1.5 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - EMPTY CASE CONVEYORS: 1.25 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE SPIRAL TO PALLETIZER: 2.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT: 2.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - EMPTY CAN: 1.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - COMPRESSOR: 2.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - PACKER 2, MODEL FENIX 185V: 3.0 hours
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE CONVEYOR: 1.0 hours

# Influence of Part Replacement Frequency by Functional Node on Time to Next Failure

# Convert relevant date columns to datetime format
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_FINISH_DATE'])

# Calculate duration from EXECUTION_FINISH_DATE to the end of observation period
data_swire_copy['duration_new'] = (data_swire_copy['EXECUTION_FINISH_DATE'].max() - data_swire_copy['EXECUTION_FINISH_DATE']).dt.days
data_swire_copy['event_new'] = 1  # Assuming all rows represent events (failure occurred)

# Filter rows where parts have been replaced based on 'ORDER_DESCRIPTION'
replace_rows = data_swire_copy[data_swire_copy['ORDER_DESCRIPTION'].str.contains('replace', case=False, na=False)]

# Initialize Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# List of functional nodes to analyze
functional_nodes = [
    'FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
    'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED',
    'FUNCTIONAL_AREA_NODE_5_MODIFIED'
]

# Analyze part replacement frequency by functional node
for node in functional_nodes:
    # Calculate top 10 most frequent values in the current node where replacements were performed
    top_values = replace_rows[node].value_counts().nlargest(10)

    print(f"\nKaplan-Meier Survival Analysis for Part Replacement Frequency by {node}")
    plt.figure(figsize=(10, 6))

    # Loop through the top 10 values for the current functional node
    for value in top_values.index:
        subset = replace_rows[replace_rows[node] == value]

        # Fit Kaplan-Meier model with duration from EXECUTION_FINISH_DATE to the observation end as the 'duration'
        kmf.fit(durations=subset['duration_new'], event_observed=subset['event_new'], label=f"{node}: {value}")

        # Print the median survival time for each node value
        median_survival_time = kmf.median_survival_time_
        print(f"Median Survival Time for {node} - {value}: {median_survival_time} days")

        # Plot the survival function
        kmf.plot_survival_function(ci_show=False)

    # Configure plot for better visualization
    plt.title(f"Kaplan-Meier Survival Curves for Part Replacement Frequency by {node}")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title=node)
    plt.grid(True)
    plt.show()

Kaplan-Meier Survival Analysis for Part Replacement Frequency by FUNCTIONAL_AREA_NODE_1_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - SILVERSTONE PRODUCTION: 1276.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - COTA PRODUCTION: 1314.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - PRODUCTION: 1022.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - SUZUKA PRODUCTION: 1329.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - MONZA PRODUCTION: 1064.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_1_MODIFIED - FLEET: 1161.0 days

Kaplan-Meier Survival Analysis for Part Replacement Frequency by FUNCTIONAL_AREA_NODE_2_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINES 1,2,9 - BOTTLE LINES: 1209.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - CAN LINE: 1229.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - BOTTLE LINE: 1400.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINES 3,4,10 - CAN LINES: 1229.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINE 2,3 PET BOTTLE LINES: 1067.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - L1, L2, L6 PET BOTTLE LINES: 1284.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - BTL_PET_LINE: 1162.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - G812 PRD FILLER_ROTARY_CAN: 1011.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - LINE 1 CAN: 962.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_2_MODIFIED - OFFICES: 1575.0 days

Kaplan-Meier Survival Analysis for Part Replacement Frequency by FUNCTIONAL_AREA_NODE_3_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #4-FILLER_ROTARY_CAN: 1171.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - FILLER_ROT_BTL_PET: 1184.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - BOTTLE_LINE_PET: 1365.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #2 - ROT_BTL_PET: 1284.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #1-CAN_LINE: 1100.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #3-CAN_LINE: 1322.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #3-FILLER_ROTARY_CAN: 1300.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #1 - ROT_BTL_PET: 1286.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE #9 - ROT_BTL_PET: 1060.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_3_MODIFIED - LINE 2 LARGET PET: 1053.0 days

Kaplan-Meier Survival Analysis for Part Replacement Frequency by FUNCTIONAL_AREA_NODE_4_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - FILLER: 1262.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - PACKER: 1169.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - CONVEYOR: 1123.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - LABELER: 1286.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - PALLETIZER: 1396.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - WRAPPER: 1169.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - RINSER: 1156.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - DEPALLETIZER: 1063.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - CAPPER: 1021.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_4_MODIFIED - WARMER_COOLER: 1265.0 days

Kaplan-Meier Survival Analysis for Part Replacement Frequency by FUNCTIONAL_AREA_NODE_5_MODIFIED
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CAN TO ACCUMULATION TABLE: 895.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE CONVEYORS: 715.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - EMPTY CASE CONVEYORS: 618.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL BOTTLE CONVEYORS: 764.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT: 778.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - PACKER 1, MODEL DUODOZEN 1250SX: 254.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - EAST SYRUP TANKS: 796.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - FULL CASE SPIRAL TO PALLETIZER: 564.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - EMPTY CAN: 848.0 days
Median Survival Time for FUNCTIONAL_AREA_NODE_5_MODIFIED - *OLD SYSTEM MT CASE CONVEYORS*: 283.0 days

import pandas as pd
from lifelines import KaplanMeierFitter
from lifelines.utils import median_survival_times
import matplotlib.pyplot as plt
import numpy as np
import re

# Load and preprocess data
data_swire_copy = pd.read_csv("IWC_Work_Orders_Extract.csv")
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy['EQUIP_START_UP_DATE'] = pd.to_datetime(data_swire_copy['EQUIP_START_UP_DATE'], errors='coerce')


# Calculate machine age and survival time
data_swire_copy['machine_age'] = (data_swire_copy['EXECUTION_START_DATE'] - data_swire_copy['EQUIP_START_UP_DATE']).dt.days

# Define event: 1 if failure occurred, 0 otherwise
data_swire_copy['failure_event'] = 1  # Assume every row represents a failure for simplicity

# Correct Equipment Type Extraction
equipment_types = ['filler', 'packer', 'blender', 'blower', 'labeler']
data_swire_copy['Equipment_Type'] = data_swire_copy['EQUIPMENT_DESC'].str.extract(r'(filler|packer|blender|blower|labeler)', flags=re.IGNORECASE)

# Check extraction success
print("Equipment types found:", data_swire_copy['Equipment_Type'].unique())

# 1. Survival Analysis for Equipment Types
plt.figure(figsize=(12, 8))
kmf = KaplanMeierFitter()

median_survival_times_dict = {}
for equipment_type in equipment_types:
    type_data = data_swire_copy[data_swire_copy['Equipment_Type'].str.contains(equipment_type, case=False, na=False)]
    if not type_data.empty:
        kmf.fit(type_data['machine_age'], event_observed=type_data['failure_event'], label=equipment_type.capitalize())
        median_survival = kmf.median_survival_time_  # Correctly access the median survival time
        median_survival_times_dict[equipment_type] = median_survival
        kmf.plot_survival_function()

plt.title("Survival Curves by Equipment Type")
plt.xlabel("Machine Age (Days)")
plt.ylabel("Survival Probability")
plt.legend(title="Equipment Type")
plt.show()

# Print survival times for validation
print("Median survival times:", median_survival_times_dict)

# 2. Simulate the Impact of Planned Maintenance for Unplanned Failures
preventability_factor = 0.8  # Assume 80% of failures before median survival time are preventable

data_swire_copy['preventive_maintenance'] = data_swire_copy.apply(
    lambda row: 1 if (
        row['machine_age'] < median_survival_times_dict.get(
            row['Equipment_Type'], float('inf')
        ) and np.random.random() < preventability_factor
    ) else 0, axis=1
)

# Compare unplanned maintenance with and without the intervention
before_intervention_unplanned = data_swire_copy['failure_event'].sum()
after_intervention_unplanned = data_swire_copy.loc[data_swire_copy['preventive_maintenance'] == 0, 'failure_event'].sum()

print(f"Unplanned maintenance events before intervention: {before_intervention_unplanned}")
print(f"Unplanned maintenance events after intervention: {after_intervention_unplanned}")

# Calculate downtime reduction for unplanned maintenance
downtime_reduction_unplanned = (before_intervention_unplanned - after_intervention_unplanned) / before_intervention_unplanned * 100
print(f"Estimated reduction in unplanned maintenance events: {downtime_reduction_unplanned:.2f}%")

# 3. Simulate the Impact of Planned Maintenance
before_intervention_planned = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned'].shape[0]

data_swire_copy['planned_maintenance_intervention'] = data_swire_copy.apply(
    lambda row: 1 if (
        row['machine_age'] < median_survival_times_dict.get(
            row['Equipment_Type'], float('inf')
        )
    ) else 0, axis=1
)

after_intervention_planned = data_swire_copy[data_swire_copy['planned_maintenance_intervention'] == 1].shape[0]

if before_intervention_planned == 0:
    planned_maintenance_improvement = "Not Applicable (No Baseline Planned Maintenance)"
else:
    planned_maintenance_improvement = (after_intervention_planned - before_intervention_planned) / before_intervention_planned * 100

print(f"Planned maintenance events before intervention: {before_intervention_planned}")
print(f"Planned maintenance events after intervention: {after_intervention_planned}")
print(f"Estimated improvement in planned maintenance: {planned_maintenance_improvement}")

# 4. Validation Checks

# Check total maintenance events
print("Total maintenance events:", data_swire_copy.shape[0])

# Verify planned and unplanned event counts
print("Planned maintenance events:", data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned'].shape[0])
print("Unplanned maintenance events:", data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned'].shape[0])

# Verify preventive maintenance flags
preventive_events = data_swire_copy[data_swire_copy['preventive_maintenance'] == 1]
print("Preventive maintenance events flagged:", preventive_events.shape[0])
print(preventive_events.head())

# Analyze remaining unplanned maintenance events
unplanned_after = data_swire_copy.loc[data_swire_copy['preventive_maintenance'] == 0]
print("Remaining unplanned events after intervention:", unplanned_after.shape[0])
print(unplanned_after.head())

# Validate planned maintenance increase
planned_events_before = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned']
planned_events_after = data_swire_copy[data_swire_copy['planned_maintenance_intervention'] == 1]
print("Planned events before intervention:", planned_events_before.shape[0])
print("Planned events after intervention:", planned_events_after.shape[0])

# Spot-check random samples for validation
print(data_swire_copy[['Equipment_Type', 'machine_age', 'failure_event',
                       'preventive_maintenance', 'planned_maintenance_intervention']].sample(10))

Equipment types found: [nan 'FILLER' 'LABELER' 'BLOWER' 'PACKER' 'BLENDER']

Median survival times: {'filler': 1237.0, 'packer': 1407.0, 'blender': 1139.0, 'blower': 1617.0, 'labeler': 1209.0}
Unplanned maintenance events before intervention: 1048575
Unplanned maintenance events after intervention: 1005972
Estimated reduction in unplanned maintenance events: 4.06%
Planned maintenance events before intervention: 104458
Planned maintenance events after intervention: 53250
Estimated improvement in planned maintenance: -49.02257366597102
Total maintenance events: 1048575
Planned maintenance events: 104458
Unplanned maintenance events: 944117
Preventive maintenance events flagged: 42603
      ORDER_ID PLANT_ID PRODUCTION_LOCATION EXECUTION_START_DATE  \
0  705642457.0     G812                ROMA           2024-05-04   
1  704191697.0     G812                ROMA           2022-09-13   
2  704466547.0     G812                ROMA           2022-12-21   
3  703834477.0     G812                ROMA           2022-07-04   
5  704948720.0     G291               MONZA           2023-09-08   

  EXECUTION_FINISH_DATE ACTUAL_START_TIME ACTUAL_FINISH_TIME  \
0             5/12/2024           00:00.0            04:08.0   
1             9/13/2022           00:00.0            17:24.0   
2            12/21/2022           00:00.0            00:00.0   
3              7/4/2022           00:00.0            00:00.0   
5              9/8/2023           00:00.0            00:00.0   

   ACTUAL_WORK_IN_MINUTES MAINTENANCE_PLAN  MAINTENANCE_ITEM  ...  \
0                   390.0              NaN               NaN  ...   
1                   420.0              NaN               NaN  ...   
2                    30.0              NaN               NaN  ...   
3                    60.0              NaN               NaN  ...   
5                    18.0       G291VM1437           40534.0  ...   

              EQUIPMENT_DESC EQUIP_CAT_DESC EQUIP_START_UP_DATE  \
0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
1  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
2  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
3  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
5          TANK_STL_STOR_AIR       Machines          2017-02-15   

  EQUIP_VALID_FROM EQUIP_VALID_TO machine_age failure_event Equipment_Type  \
0        2/10/2020     12/31/9999      1473.0             1            NaN   
1        2/10/2020     12/31/9999       874.0             1            NaN   
2        2/10/2020     12/31/9999       973.0             1            NaN   
3        2/10/2020     12/31/9999       803.0             1            NaN   
5       12/11/2023     12/31/9999      2396.0             1            NaN   

  preventive_maintenance  planned_maintenance_intervention  
0                      1                                 1  
1                      1                                 1  
2                      1                                 1  
3                      1                                 1  
5                      1                                 1  

[5 rows x 30 columns]
Remaining unplanned events after intervention: 1005972
       ORDER_ID PLANT_ID PRODUCTION_LOCATION EXECUTION_START_DATE  \
4   704661125.0     G291               MONZA           2023-03-15   
9   704448350.0     G291               MONZA           2022-12-13   
11  705845653.0     G291               MONZA           2024-07-30   
13  704583800.0     G291               MONZA           2023-02-09   
19  704660973.0     G291               MONZA           2023-03-15   

   EXECUTION_FINISH_DATE ACTUAL_START_TIME ACTUAL_FINISH_TIME  \
4              3/15/2023           00:00.0            00:00.0   
9             12/13/2022           00:00.0            00:00.0   
11             7/30/2024           00:00.0            00:00.0   
13              2/9/2023           00:00.0            00:00.0   
19             3/15/2023           00:00.0            00:00.0   

    ACTUAL_WORK_IN_MINUTES MAINTENANCE_PLAN  MAINTENANCE_ITEM  ...  \
4                    120.0              NaN               NaN  ...   
9                     30.0              NaN               NaN  ...   
11                   240.0              NaN               NaN  ...   
13                    30.0              NaN               NaN  ...   
19                    30.0              NaN               NaN  ...   

                 EQUIPMENT_DESC EQUIP_CAT_DESC EQUIP_START_UP_DATE  \
4             TANK_STL_STOR_AIR       Machines          2017-02-15   
9   PUMP_RECIP_HIGH_PRESSURE_NF       Machines          2017-02-15   
11  PUMP_RECIP_HIGH_PRESSURE_NF       Machines          2017-02-15   
13  PUMP_RECIP_HIGH_PRESSURE_NF       Machines          2017-02-15   
19  PUMP_RECIP_HIGH_PRESSURE_NF       Machines          2017-02-15   

   EQUIP_VALID_FROM EQUIP_VALID_TO machine_age failure_event Equipment_Type  \
4        12/11/2023     12/31/9999      2219.0             1            NaN   
9        12/11/2023     12/31/9999      2127.0             1            NaN   
11       12/11/2023     12/31/9999      2722.0             1            NaN   
13       12/11/2023     12/31/9999      2185.0             1            NaN   
19       12/11/2023     12/31/9999      2219.0             1            NaN   

   preventive_maintenance  planned_maintenance_intervention  
4                       0                                 1  
9                       0                                 1  
11                      0                                 1  
13                      0                                 1  
19                      0                                 1  

[5 rows x 30 columns]
Planned events before intervention: 104458
Planned events after intervention: 53250
       Equipment_Type  machine_age  failure_event  preventive_maintenance  \
577200            NaN          NaN              1                       0   
749214            NaN          NaN              1                       0   
919038            NaN          NaN              1                       0   
94933             NaN       1564.0              1                       1   
827505            NaN          NaN              1                       0   
870622            NaN          NaN              1                       0   
538812            NaN          NaN              1                       0   
592517            NaN          NaN              1                       0   
933526         FILLER       1701.0              1                       1   
850844            NaN          NaN              1                       0   

        planned_maintenance_intervention  
577200                                 0  
749214                                 0  
919038                                 0  
94933                                  1  
827505                                 0  
870622                                 0  
538812                                 0  
592517                                 0  
933526                                 1  
850844                                 0

# Sort data by equipment and date
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Define equipment categories
categories = {
    'filler': r'(filler)',
    'blender': r'(blender)',
    'labeler': r'(labeler)',
    'packer': r'(packer)',
    'palletizer': r'(palletizer)',
    'seamer': r'(seamer)',
    'rinser': r'(rinser)',
    'capper': r'(capper)',
    'tank': r'(tank)',
    'warmer': r'(warmer)',
    'pump': r'(pump)',
    'mixer': r'(mixer)',
    'conveyor': r'(conveyor)',
    'compressor': r'(compressor)',
    'boiler': r'(boiler)',
    'chiller': r'(chiller)'
}

# Categorize equipment
def categorize_equipment(description):
    for category, pattern in categories.items():
        if pd.notna(description) and pd.Series(description).str.contains(pattern, regex=True, case=False).any():
            return category
    return 'other'

data_swire_copy['Equipment_Type'] = data_swire_copy['EQUIPMENT_DESC'].apply(categorize_equipment)

# Calculate MTBF for each equipment type
data_swire_copy['MTBF_Days'] = data_swire_copy.groupby(['Equipment_Type', 'EQUIPMENT_ID'])['EXECUTION_START_DATE'].diff().dt.days

# Group by equipment type and calculate MTBF statistics
mtbf_stats = data_swire_copy.groupby('Equipment_Type')['MTBF_Days'].agg(
    Total_MTBF_Days='sum',
    Average_MTBF_Days='mean',
    Min_MTBF_Days='min',
    Max_MTBF_Days='max',
    Count='count'
).reset_index()

# Filter out the "other" category if necessary
mtbf_stats = mtbf_stats[mtbf_stats['Equipment_Type'] != 'other']

# Display the MTBF statistics
print("\nMTBF Statistics by Equipment Type:")
print(mtbf_stats)

MTBF Statistics by Equipment Type:
   Equipment_Type  Total_MTBF_Days  Average_MTBF_Days  Min_MTBF_Days  \
0         blender           2156.0          29.534247            0.0   
1          boiler           2337.0           9.348000            0.0   
2          capper           2160.0          30.000000            0.0   
3         chiller           4839.0          38.712000            0.0   
4      compressor           2103.0           9.064655            0.0   
5        conveyor          14962.0          67.094170            0.0   
6          filler          14121.0           1.694181            0.0   
7         labeler          28212.0           4.800408            0.0   
8           mixer          15368.0          24.393651            0.0   
10         packer          15184.0           5.338959            0.0   
11     palletizer          21412.0           8.568227            0.0   
12           pump          33068.0          34.445833            0.0   
13         rinser          21214.0           7.859948            0.0   
14         seamer          17749.0           5.336440            0.0   
15           tank          74663.0          40.467751            0.0   
16         warmer          17436.0          14.152597            0.0   

    Max_MTBF_Days  Count  
0           228.0     73  
1           447.0    250  
2           319.0     72  
3           354.0    125  
4           341.0    232  
5          1533.0    223  
6          1040.0   8335  
7          1757.0   5877  
8           770.0    630  
10          477.0   2844  
11          244.0   2499  
12         1936.0    960  
13          792.0   2699  
14         1250.0   3326  
15         2039.0   1845  
16         2027.0   1232

import pandas as pd
import numpy as np

# Load data
data_swire_copy = pd.read_csv("IWC_Work_Orders_Extract.csv")
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy['EQUIP_START_UP_DATE'] = pd.to_datetime(data_swire_copy['EQUIP_START_UP_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE', 'EQUIP_START_UP_DATE'])

# Machine age and survival metrics
data_swire_copy['machine_age'] = (data_swire_copy['EXECUTION_START_DATE'] - data_swire_copy['EQUIP_START_UP_DATE']).dt.days

# Equipment survival statistics (from earlier analysis)
median_survival_times_dict = {'filler': 1256.0, 'packer': 1366.0, 'blender': 1122.0, 'blower': 1617.0, 'labeler': 1230.0}

# 1. Prioritize high-risk equipment
high_risk_equipment = ['blender', 'filler']  # Based on survival curves and unplanned maintenance

# Filter data for high-risk equipment
data_high_risk = data_swire_copy[data_swire_copy['EQUIPMENT_DESC'].str.contains('|'.join(high_risk_equipment), case=False, na=False)]

# 2. Count breakdown frequencies for high-risk equipment
breakdown_counts = data_high_risk['EQUIPMENT_DESC'].value_counts()

# Print breakdown frequencies
print("Breakdown frequencies for high-risk equipment:")
print(breakdown_counts)

# 3. Simulate inventory requirements for high-risk equipment
# Assume 1 spare part required per failure
inventory_requirements = breakdown_counts.copy()

# Add planned and preventive maintenance flags
data_high_risk['planned_or_preventive'] = (
    (data_high_risk['machine_age'] < median_survival_times_dict.get(data_high_risk['EQUIPMENT_DESC'].str.extract(r'(blender|filler)', expand=False).iloc[0], float('inf')))
)

# Simulate scenarios
no_inventory_downtime = breakdown_counts * 2  # Assume 2 hours of downtime per failure without inventory
sufficient_inventory_downtime = breakdown_counts * 0.5  # Assume 30 minutes downtime with inventory

# 4. Compare scenarios
inventory_impact = pd.DataFrame({
    "Equipment": breakdown_counts.index,
    "Failures (Count)": breakdown_counts.values,
    "Downtime Without Inventory (Hours)": no_inventory_downtime.values,
    "Downtime With Inventory (Hours)": sufficient_inventory_downtime.values,
    "Spares Needed": inventory_requirements.values
})

# Display results
print("\nStrategic Inventory Impact Analysis:")
print(inventory_impact)

Breakdown frequencies for high-risk equipment:
EQUIPMENT_DESC
L1 FILLER_ROTARY_CAN_72_VALVE         3745
L1 FILLER_ROTARY_BTL_60_VALVE         2738
L4 FILLER_ROTARY_CAN_100_VALVE        2511
L2 FILLER_ROTARY_BTL_45_VALVE         2072
L3 FILLER_ROTARY_BTL_100_VALVE        1474
L3 FILLER_ROTARY_CAN_124_VALVE         754
L2 LINE 2 FILLER                       354
MICROBLEND MICRO2 BLENDER (LINE 1)      44
L2 MICROBLEND MICRO2 BLENDER            43
MICROBLEND MICRO2 BLENDER (LINE 3)      31
APS - M1, FILLER DISCHARGE              16
L3 FILLER CIP SYSTEM                    16
FILLER ACCUMULATION TABLE               12
ALLIANCE FILLER DISCHARGE - M10          8
TANK_SS_STOR_FILLER_SUPPLY L3            6
TANK_SS_STOR_FILLER_RETURN L3            6
PUMP_CENT_SANIT_FILLER_SUPPLY L3         5
L10 FILLER_ROTARY_CAN_                   4
PUMP_CENT_SANIT_FILLER_RETURN L3         1
PUMP_CENT_SANIT_FILLER_SUPPLY            1
Name: count, dtype: int64

Strategic Inventory Impact Analysis:
                             Equipment  Failures (Count)  \
0        L1 FILLER_ROTARY_CAN_72_VALVE              3745   
1        L1 FILLER_ROTARY_BTL_60_VALVE              2738   
2       L4 FILLER_ROTARY_CAN_100_VALVE              2511   
3        L2 FILLER_ROTARY_BTL_45_VALVE              2072   
4       L3 FILLER_ROTARY_BTL_100_VALVE              1474   
5       L3 FILLER_ROTARY_CAN_124_VALVE               754   
6                     L2 LINE 2 FILLER               354   
7   MICROBLEND MICRO2 BLENDER (LINE 1)                44   
8         L2 MICROBLEND MICRO2 BLENDER                43   
9   MICROBLEND MICRO2 BLENDER (LINE 3)                31   
10          APS - M1, FILLER DISCHARGE                16   
11                L3 FILLER CIP SYSTEM                16   
12           FILLER ACCUMULATION TABLE                12   
13     ALLIANCE FILLER DISCHARGE - M10                 8   
14       TANK_SS_STOR_FILLER_SUPPLY L3                 6   
15       TANK_SS_STOR_FILLER_RETURN L3                 6   
16    PUMP_CENT_SANIT_FILLER_SUPPLY L3                 5   
17              L10 FILLER_ROTARY_CAN_                 4   
18    PUMP_CENT_SANIT_FILLER_RETURN L3                 1   
19       PUMP_CENT_SANIT_FILLER_SUPPLY                 1   

    Downtime Without Inventory (Hours)  Downtime With Inventory (Hours)  \
0                                 7490                           1872.5   
1                                 5476                           1369.0   
2                                 5022                           1255.5   
3                                 4144                           1036.0   
4                                 2948                            737.0   
5                                 1508                            377.0   
6                                  708                            177.0   
7                                   88                             22.0   
8                                   86                             21.5   
9                                   62                             15.5   
10                                  32                              8.0   
11                                  32                              8.0   
12                                  24                              6.0   
13                                  16                              4.0   
14                                  12                              3.0   
15                                  12                              3.0   
16                                  10                              2.5   
17                                   8                              2.0   
18                                   2                              0.5   
19                                   2                              0.5   

    Spares Needed  
0            3745  
1            2738  
2            2511  
3            2072  
4            1474  
5             754  
6             354  
7              44  
8              43  
9              31  
10             16  
11             16  
12             12  
13              8  
14              6  
15              6  
16              5  
17              4  
18              1  
19              1

import pandas as pd

# Convert execution start date to datetime and drop rows with invalid dates
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')


# Sort data by machine and by date
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time difference (in days) between consecutive failures for each machine
data_swire_copy['MTBF_Days'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Calculate breakdown count for each machine
breakdown_count = data_swire_copy['EQUIPMENT_ID'].value_counts()

# Define risk thresholds
# High breakdown count threshold (top 10%)
breakdown_threshold = breakdown_count.quantile(0.9)

# Short MTBF threshold (bottom 10% of all MTBF values)
mtbf_threshold = data_swire_copy['MTBF_Days'].quantile(0.1)

# Create a risk assessment table
risk_table = pd.DataFrame({
    'Breakdown_Count': breakdown_count,
    'Original_MTBF_Days': data_swire_copy.groupby('EQUIPMENT_ID')['MTBF_Days'].apply(list)
})

# Determine risk status based on thresholds
risk_table['Risk_Status'] = risk_table.apply(
    lambda row: 'At Risk' if (row['Breakdown_Count'] >= breakdown_threshold) or
                                (any(mtbf <= mtbf_threshold for mtbf in row['Original_MTBF_Days'] if pd.notna(mtbf))) else 'Low Risk', axis=1
)

# Filter for at-risk equipment
at_risk_equipments = risk_table[risk_table['Risk_Status'] == 'At Risk']

# Sort the at-risk equipment by Breakdown Count in descending order
# and Original MTBF (shortest first)
at_risk_equipments = at_risk_equipments.sort_values(
    by=['Breakdown_Count'],
    ascending=[False]
)

# Get the top 10 at-risk equipment
top_10_at_risk_equipments = at_risk_equipments.head(10)

# Reset index for a clean display
top_10_at_risk_equipments.reset_index().rename(columns={'index': 'Equipment_ID'}, inplace=True)

# Display the top 10 at-risk equipment
print(top_10_at_risk_equipments)

              Breakdown_Count  \
EQUIPMENT_ID                    
300115000.0              3745   
300025792.0              3311   
300017655.0              3060   
300001113.0              2738   
300026891.0              2222   
300017654.0              2124   
300009199.0              1909   
300001078.0              1853   
300017247.0              1712   
300009177.0              1664   

                                             Original_MTBF_Days Risk_Status  
EQUIPMENT_ID                                                                 
300115000.0   [nan, 1.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, ...     At Risk  
300025792.0   [nan, 1.0, 2.0, 0.0, 5.0, 2.0, 0.0, 0.0, 0.0, ...     At Risk  
300017655.0   [nan, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0, 2.0, 1.0, ...     At Risk  
300001113.0   [nan, 2.0, 1.0, 0.0, 1.0, 8.0, 5.0, 1.0, 0.0, ...     At Risk  
300026891.0   [nan, 2.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, ...     At Risk  
300017654.0   [nan, 0.0, 2.0, 3.0, 0.0, 2.0, 14.0, 0.0, 2.0,...     At Risk  
300009199.0   [nan, 1.0, 5.0, 0.0, 3.0, 0.0, 1.0, 0.0, 1.0, ...     At Risk  
300001078.0   [nan, 0.0, 0.0, 5.0, 2.0, 0.0, 1.0, 1.0, 4.0, ...     At Risk  
300017247.0   [nan, 0.0, 2.0, 1.0, 4.0, 2.0, 2.0, 2.0, 1.0, ...     At Risk  
300009177.0   [nan, 4.0, 3.0, 0.0, 2.0, 0.0, 0.0, 1.0, 0.0, ...     At Risk

	ACTUAL_WORK_IN_MINUTES
count	1427264.00
mean	88.63
std	803.79
min	0.00
25%	12.00
50%	48.00
75%	90.00
max	330184.80

	Average_Interval_Days	Average_Interval_Weeks
EQUIPMENT_ID
300001510.0	1.348342	0.192620
300001113.0	1.407007	0.201001
300001078.0	1.566667	0.223810
300254600.0	1.580838	0.225834
300001612.0	1.625714	0.232245
...	...	...
300001144.0	389.000000	55.571429
300001266.0	417.600000	59.657143
300001325.0	464.000000	66.285714
300001054.0	545.500000	77.928571
400022400.0	640.000000	91.428571

model	lifelines.CoxPHFitter
duration col	'duration_new'
event col	'event_new'
baseline estimation	breslow
number of observations	23393
number of events observed	23393
partial log-likelihood	-211783.00
time fit was run	2024-11-07 22:57:58 UTC

	coef	exp(coef)	se(coef)	coef lower 95%	coef upper 95%	exp(coef) lower 95%	exp(coef) upper 95%	cmp to	z	p	-log2(p)
MAINTENANCE_TYPE_DESCRIPTION_Corrective Maintenance Order	-1.39	0.25	0.06	-1.51	-1.26	0.22	0.28	0.00	-22.31	<0.005	363.93
MAINTENANCE_TYPE_DESCRIPTION_Preventive Maintenance Order	-1.52	0.22	0.14	-1.79	-1.25	0.17	0.29	0.00	-11.10	<0.005	92.75

Concordance	0.51
Partial AIC	423569.99
log-likelihood ratio test	336.05 on 2 df
-log2(p) of ll-ratio test	242.41

	ORDER_ID	PLANT_ID	PRODUCTION_LOCATION	EXECUTION_START_DATE	EXECUTION_FINISH_DATE	ACTUAL_START_TIME	ACTUAL_FINISH_TIME	ACTUAL_WORK_IN_MINUTES	MAINTENANCE_PLAN	MAINTENANCE_ITEM	...	FUNCTIONAL_AREA_NODE_2_MODIFIED	FUNCTIONAL_AREA_NODE_3_MODIFIED	FUNCTIONAL_AREA_NODE_4_MODIFIED	FUNCTIONAL_AREA_NODE_5_MODIFIED	EQUIPMENT_ID	EQUIPMENT_DESC	EQUIP_CAT_DESC	EQUIP_START_UP_DATE	EQUIP_VALID_FROM	EQUIP_VALID_TO
0	705642457	G812	ROMA	2024-05-04	2024-05-12	06:00:00.000	23:04:08.000	390.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
1	704191697	G812	ROMA	2022-09-13	2022-09-13	06:00:00.000	17:17:24.000	420.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
2	704466547	G812	ROMA	2022-12-21	2022-12-21	07:00:00.000	07:00:00.000	30.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
3	703834477	G812	ROMA	2022-07-04	2022-07-04	06:00:00.000	06:00:00.000	60.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
4	704661125	G291	MONZA	2023-03-15	2023-03-15	07:00:00.000	07:00:00.000	120.0	NaN	NaN	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2017-02-15	2023-12-11	9999-12-31
5	704948720	G291	MONZA	2023-09-08	2023-09-08	07:00:00.000	07:00:00.000	18.0	G291VM1437	40534.0	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2017-02-15	2023-12-11	9999-12-31
6	701673970	G291	MONZA	2019-09-06	2019-09-06	07:00:00.000	07:00:00.000	480.0	NaN	NaN	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2017-02-15	2023-12-11	9999-12-31
7	705148892	G291	MONZA	2023-10-09	2023-10-09	07:00:00.000	07:00:00.000	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2017-02-15	2023-12-11	9999-12-31
8	704769592	G291	MONZA	2023-05-01	2023-05-01	07:00:00.000	07:00:00.000	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2017-02-15	2023-12-11	9999-12-31
9	704448350	G291	MONZA	2022-12-13	2022-12-13	08:00:00.000	08:00:00.000	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2017-02-15	2023-12-11	9999-12-31

	0
ORDER_ID	int64
PLANT_ID	object
PRODUCTION_LOCATION	object
EXECUTION_START_DATE	object
EXECUTION_FINISH_DATE	object
ACTUAL_START_TIME	object
ACTUAL_FINISH_TIME	object
ACTUAL_WORK_IN_MINUTES	float64
MAINTENANCE_PLAN	object
MAINTENANCE_ITEM	float64
MAINTENANCE_ACTIVITY_TYPE	object
ORDER_DESCRIPTION	object
MAINTENANCE_TYPE_DESCRIPTION	object
FUNCTIONAL_LOC	object
FUNCTIONAL_AREA_NODE_1_MODIFIED	object
FUNCTIONAL_AREA_NODE_2_MODIFIED	object
FUNCTIONAL_AREA_NODE_3_MODIFIED	object
FUNCTIONAL_AREA_NODE_4_MODIFIED	object
FUNCTIONAL_AREA_NODE_5_MODIFIED	object
EQUIPMENT_ID	float64
EQUIPMENT_DESC	object
EQUIP_CAT_DESC	object
EQUIP_START_UP_DATE	object
EQUIP_VALID_FROM	object
EQUIP_VALID_TO	object

	Equipment_ID	Equipment_Description	Breakdown_Count	Equipment_Type
18	300115000.0	L1 FILLER_ROTARY_CAN_72_VALVE	3745.0	Filler
1019	300001576.0	LABELER_SPOT_TAG_APPLICATOR	1.0	Labeler
1228	300111000.0	L2 LABELER_BOTTLE_TRINE 4600_#1	1066.0	Labeler
1231	300001560.0	L3 LABELER_ROTARY	931.0	Labeler
1239	300111001.0	L2 LABELER_BOTTLE_TRINE 4600_#2	902.0	Labeler
...	...	...	...	...
2893	300001559.0	L3 LABELER_ROTARY	1024.0	Labeler
2914	300045259.0	L2 ALLIANCE-CCF201 PACKER DISCHARGE	14.0	Packer
2917	300153418.0	L2 MICROBLEND MICRO2 BLENDER	43.0	Blender
2932	300129003.0	L3 FILLER CIP SYSTEM	16.0	Filler
2947	300126807.0	CAN LINE 3 HICONE PACKER	100.0	Packer

	FUNCTIONAL_AREA_NODE_1_MODIFIED	FUNCTIONAL_AREA_NODE_2_MODIFIED	FUNCTIONAL_AREA_NODE_3_MODIFIED	FUNCTIONAL_AREA_NODE_4_MODIFIED	FUNCTIONAL_AREA_NODE_5_MODIFIED	Maintenance_Frequency	Average_Downtime
0	MONZA PRODUCTION	ROTARY_CAN_LINE	LINE #4-FILLER_ROTARY_CAN	PACKER	PACKER 1, MODEL DUODOZEN 1250SX	210	208.837143
1	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 2 LARGET PET	CONVEYOR	FULL CASE CONVEYORS	158	131.403797
2	PRODUCTION	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CASE CONVEYOR	89	68.939326
3	PRODUCTION	LINE 1 CAN	LINE 1 CAN	CONVEYOR	EMPTY CAN	67	103.916418
4	PRODUCTION	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	EMPTY CAN CONVEYOR	66	104.190909
5	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 2 LARGET PET	CONVEYOR	EMPTY CASE CONVEYORS	59	113.552542
6	MONZA PRODUCTION	BTL_PET_LINE	LINE #3 - FILLER_ROT_BTL_PET	WARMER_COOLER	EVANS COOLING TUNNEL L3, INSIDE BUILDING	43	117.530233
7	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 3 SMALL PET	CONVEYOR	LOOSE FB TO PACKER CONVEYORS	29	82.758621
8	PRODUCTION	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	20	134.250000
9	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 3 SMALL PET	CONVEYOR	FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT	16	322.500000

year	2017	2018	2019	2020	2021	2022	2023	2024
EQUIPMENT_ID
300001510.0	227	440	429	300	261	148	126	91
300001113.0	133	289	317	288	243	253	267	152
300001078.0	310	431	348	180	148	115	124	85
300001276.0	250	347	305	173	135	65	68	60
300001133.0	125	180	235	180	178	158	137	52
300001248.0	191	262	266	156	97	73	102	81
300001580.0	97	164	183	180	156	125	125	115
300001505.0	85	183	228	155	121	80	146	29
300001246.0	187	290	315	145	35	11	19	2
300001509.0	62	92	119	109	100	120	212	80

Swire Coca-Cola Capstone Modeling - Group 8

Author : Charith Reddy Gopavaram

Table of contents:¶

1. Introduction ¶

2. Load Libraries and packages ¶

3. Import dataset and inspect ¶

4. Missing Value analysis ¶

4.1 Imputation of Missing Value's ¶

5.Univariate analysis ¶

5.1. Distribution of actual work in minutes ¶

5.2. Breakdown counts by production location ¶

5.3. Breakdown trends over years ¶

5.4. Number of maintenance activites per month in 2023 ¶

5.5. Frequency of maintenance activity type ¶

6.Bivariate analysis ¶

6.1 Average downtime by maintenance activity type ¶

6.2 Average downtime by plant ¶

6.3 Count of Maintenance type by maintenance activity type ¶

6.4 Production line Analysis using Functional Area ¶

6.4.1 Average downtime by functional area node 4 ¶

6.4.2 Average downtime by functional area node 5 ¶

6.5 Frequency of Maintenance Type Across Equipment Categories ¶

6.6 Scatter Plot of Equipment Age vs Actual Work in Minutes ¶

7.Multivariate analysis ¶

7.1 Average Downtime by Maintenance Activity Type for Different Plants ¶

7.2 Maintenance Type by Equipment Age and Downtime ¶

8. Outlier Analysis ¶

9. Feature Engineering ¶

9.1 Breakdown Analysis by Equipment Type ¶

9.2 Breakdown Timeline Analysis ¶

9.3 Machine Location and Granular Analysis ¶

9.4 Nature of Repairs and Correction Methods ¶

9.5. Equipment-Specific Time Between Failures ¶

9.6 Maintenance Frequency and Downtime ¶

9.7. Time Until Next Downtime Post-Maintenance ¶

9.8 Seasonal Impact and Cost Analysis ¶

9.9 Key Features for Modeling ¶

10. Model Selection ¶

11. Modeling ¶

11.1 ARIMA Model ¶

11.2 Functional Location Segmentation for Process Analysis ¶

11.3 Kaplan-Meier Model ¶

11.4 Cox Proportional Model ¶

11.5 Leveraging Kaplan-Meier Model for Enhanced Insights ¶

11.6 Kaplan-Meier Analysis for Functional Nodes ¶

12. Results from Modeling ¶

13. Summary and Predictions ¶

14. Individual Contributions ¶